home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #11 / Amiga Plus CD - 2004 - No. 11.iso / AmiSoft / Comm / www / tidy_os4.lha / tidy / src / access.c next >
C/C++ Source or Header  |  2004-07-25  |  106KB  |  3,673 lines
  1. /* access.c -- carry out accessibility checks
  2.  
  3.   Copyright University of Toronto
  4.   Portions (c) 1998-2004 (W3C) MIT, ERCIM, Keio University
  5.   See tidy.h for the copyright notice.
  6.   
  7.   CVS Info :
  8.  
  9.     $Author: hoehrmann $ 
  10.     $Date: 2004/06/18 20:58:38 $ 
  11.     $Revision: 1.11 $ 
  12.  
  13. */
  14.  
  15. /*********************************************************************
  16. * AccessibilityChecks
  17. *
  18. * Carries out processes for all accessibility checks.  Traverses
  19. * through all the content within the tree and evaluates the tags for
  20. * accessibility.
  21. *
  22. * To perform the following checks, 'AccessibilityChecks' must be
  23. * called AFTER the tree structure has been formed.
  24. *
  25. * If, in the command prompt, there is no specification of which
  26. * accessibility priorities to check, no accessibility checks will be 
  27. * performed.  (ie. '1' for priority 1, '2' for priorities 1 and 2, 
  28. *                  and '3') for priorities 1, 2 and 3.)
  29. *
  30. * Copyright University of Toronto
  31. * Programmed by: Mike Lam and Chris Ridpath
  32. * Modifications by : Terry Teague (TRT)
  33. *
  34. *********************************************************************/
  35.  
  36. #include "tidy-int.h"
  37.  
  38. #if SUPPORT_ACCESSIBILITY_CHECKS
  39.  
  40. #include "access.h"
  41. #include "message.h"
  42. #include "tags.h"
  43. #include "attrs.h"
  44. #include "tmbstr.h"
  45.  
  46.  
  47. /* 
  48.     The accessibility checks to perform depending on user's desire.
  49.  
  50.     1. priority 1
  51.     2. priority 1 & 2
  52.     3. priority 1, 2, & 3
  53. */
  54.  
  55. /* List of possible image types */
  56. static const ctmbstr imageExtensions[] =
  57. {".jpg", ".gif", ".tif", ".pct", ".pic", ".iff", ".dib",
  58.  ".tga", ".pcx", ".png", ".jpeg", ".tiff", ".bmp"};
  59.  
  60. #define N_IMAGE_EXTS (sizeof(imageExtensions)/sizeof(ctmbstr))
  61.  
  62. /* List of possible sound file types */
  63. static const ctmbstr soundExtensions[] =
  64. {".wav", ".au", ".aiff", ".snd", ".ra", ".rm"};
  65.  
  66. static const int soundExtErrCodes[] = 
  67. {
  68.     AUDIO_MISSING_TEXT_WAV,
  69.     AUDIO_MISSING_TEXT_AU,
  70.     AUDIO_MISSING_TEXT_AIFF,
  71.     AUDIO_MISSING_TEXT_SND,
  72.     AUDIO_MISSING_TEXT_RA,
  73.     AUDIO_MISSING_TEXT_RM
  74. };
  75.  
  76. #define N_AUDIO_EXTS (sizeof(soundExtensions)/sizeof(ctmbstr))
  77.  
  78. /* List of possible media extensions */
  79. static const ctmbstr mediaExtensions[] = 
  80. {".mpg", ".mov", ".asx", ".avi", ".ivf", ".m1v", ".mmm", ".mp2v",
  81.  ".mpa", ".mpe", ".mpeg", ".ram", ".smi", ".smil", ".swf",
  82.  ".wm", ".wma", ".wmv"};
  83.  
  84. #define N_MEDIA_EXTS (sizeof(mediaExtensions)/sizeof(ctmbstr))
  85.  
  86. /* List of possible frame sources */
  87. static const ctmbstr frameExtensions[] =
  88. {".htm", ".html", ".shtm", ".shtml", ".cfm", ".cfml",
  89. ".asp", ".cgi", ".pl", ".smil"};
  90.  
  91. #define N_FRAME_EXTS (sizeof(frameExtensions)/sizeof(ctmbstr))
  92.  
  93. /* List of possible colour values */
  94. static const int colorValues[][3] =
  95. {
  96.   {  0,  0,  0},
  97.   {128,128,128},
  98.   {192,192,192},
  99.   {255,255,255},
  100.   {192,  0,  0},
  101.   {255,  0,  0},
  102.   {128,  0,128},
  103.   {255,  0,255},
  104.   {  0,128,  0},
  105.   {  0,255,  0},
  106.   {128,128,  0},
  107.   {255,255,  0},  
  108.   {  0,  0,128},
  109.   {  0,  0,255},
  110.   {  0,128,128},
  111.   {  0,255,255}
  112. };
  113.  
  114. #define N_COLOR_VALS (sizeof(colorValues)/(sizeof(int[3]))
  115.  
  116. /* These arrays are used to convert color names to their RGB values */
  117. static const ctmbstr colorNames[] =
  118. {
  119.   "black",
  120.   "silver",
  121.   "grey",
  122.   "white",
  123.   "maroon",
  124.   "red",
  125.   "purple",
  126.   "fuchsia",
  127.   "green",
  128.   "lime",
  129.   "olive",
  130.   "yellow", 
  131.   "navy",
  132.   "blue",
  133.   "teal",
  134.   "aqua"
  135. };
  136.  
  137. #define N_COLOR_NAMES (sizeof(colorNames)/sizeof(ctmbstr))
  138. #define N_COLORS N_COLOR_NAMES
  139.  
  140.  
  141. /* function prototypes */
  142. void InitAccessibilityChecks( TidyDocImpl* doc, int level123 );
  143. void FreeAccessibilityChecks( TidyDocImpl* doc );
  144.  
  145. static Bool GetRgb( ctmbstr color, int rgb[3] );
  146. static Bool CompareColors( int rgbBG[3], int rgbFG[3] );
  147. static int  ctox( tmbchar ch );
  148.  
  149. /*
  150. static void CheckMapAccess( TidyDocImpl* doc, Node* node, Node* front);
  151. static void GetMapLinks( TidyDocImpl* doc, Node* node, Node* front);
  152. static void CompareAnchorLinks( TidyDocImpl* doc, Node* front, int counter);
  153. static void FindMissingLinks( TidyDocImpl* doc, Node* node, int counter);
  154. */
  155. static void CheckFormControls( TidyDocImpl* doc, Node* node );
  156. static void MetaDataPresent( TidyDocImpl* doc, Node* node );
  157. static void CheckEmbed( TidyDocImpl* doc, Node* node );
  158. static void CheckListUsage( TidyDocImpl* doc, Node* node );
  159.  
  160. /*
  161.     GetFileExtension takes a path and returns the extension
  162.     portion of the path (if any).
  163. */
  164.  
  165. static void GetFileExtension( ctmbstr path, tmbchar *ext, uint maxExt )
  166. {
  167.     int i = tmbstrlen(path) - 1;
  168.     
  169.     ext[0] = '\0';
  170.     
  171.     do {
  172.         if ( path[i] == '/' || path[i] == '\\' )
  173.             break;
  174.         else if ( path[i] == '.' )
  175.         {
  176.             tmbstrncpy( ext, path+i, maxExt );
  177.             break;
  178.         }
  179.     } while ( --i > 0 );
  180. }
  181.  
  182. /************************************************************************
  183. * IsImage
  184. *
  185. * Checks if the given filename is an image file.
  186. * Returns 'yes' if it is, 'no' if it's not.
  187. ************************************************************************/
  188.  
  189. static Bool IsImage( ctmbstr iType )
  190. {
  191.     int i;
  192.  
  193.     /* Get the file extension */
  194.     tmbchar ext[20];
  195.     GetFileExtension( iType, ext, sizeof(ext) );
  196.  
  197.     /* Compare it to the array of known image file extensions */
  198.     for (i = 0; i < N_IMAGE_EXTS; i++)
  199.     {
  200.         if ( tmbstrcasecmp(ext, imageExtensions[i]) == 0 )
  201.             return yes;
  202.     }
  203.     
  204.     return no;
  205. }
  206.  
  207.  
  208. /***********************************************************************
  209. * IsSoundFile
  210. *
  211. * Checks if the given filename is a sound file.
  212. * Returns 'yes' if it is, 'no' if it's not.
  213. ***********************************************************************/
  214.  
  215. static int IsSoundFile( ctmbstr sType )
  216. {
  217.     int i;
  218.     tmbchar ext[ 20 ];
  219.     GetFileExtension( sType, ext, sizeof(ext) );
  220.  
  221.     for (i = 0; i < N_AUDIO_EXTS; i++)
  222.     {
  223.         if ( tmbstrcasecmp(ext, soundExtensions[i]) == 0 )
  224.             return soundExtErrCodes[i];
  225.     }
  226.     return 0;
  227. }
  228.  
  229.  
  230. /***********************************************************************
  231. * IsValidSrcExtension
  232. *
  233. * Checks if the 'SRC' value within the FRAME element is valid
  234. * The 'SRC' extension must end in ".htm", ".html", ".shtm", ".shtml", 
  235. * ".cfm", ".cfml", ".asp", ".cgi", ".pl", or ".smil"
  236. *
  237. * Returns yes if it is, returns no otherwise.
  238. ***********************************************************************/
  239.  
  240. static Bool IsValidSrcExtension( ctmbstr sType )
  241. {
  242.     int i;
  243.     tmbchar ext[20];
  244.     GetFileExtension( sType, ext, sizeof(ext) );
  245.  
  246.     for (i = 0; i < N_FRAME_EXTS; i++)
  247.     {
  248.         if ( tmbstrcasecmp(ext, frameExtensions[i]) == 0 )
  249.             return yes;
  250.     }
  251.     return no;
  252. }
  253.  
  254.  
  255. /*********************************************************************
  256. * IsValidMediaExtension
  257. *
  258. * Checks to warn the user that syncronized text equivalents are 
  259. * required if multimedia is used.
  260. *********************************************************************/
  261.  
  262. static Bool IsValidMediaExtension( ctmbstr sType )
  263. {
  264.     int i;
  265.     tmbchar ext[20];
  266.     GetFileExtension( sType, ext, sizeof(ext) );
  267.  
  268.     for (i = 0; i < N_MEDIA_EXTS; i++)
  269.     {
  270.         if ( tmbstrcasecmp(ext, mediaExtensions[i]) == 0 )
  271.             return yes;
  272.     }
  273.     return no;
  274. }
  275.  
  276.  
  277. /************************************************************************
  278. * IsWhitespace
  279. *
  280. * Checks if the given string is all whitespace.
  281. * Returns 'yes' if it is, 'no' if it's not.
  282. ************************************************************************/
  283.  
  284. static Bool IsWhitespace( ctmbstr pString )
  285. {
  286.     Bool isWht = yes;
  287.     ctmbstr cp;
  288.  
  289.     for ( cp = pString; isWht && cp && *cp; ++cp )
  290.     {
  291.         isWht = IsWhite( *cp );
  292.     }
  293.     return isWht;
  294. }
  295.  
  296. static Bool hasValue( AttVal* av )
  297. {
  298.   return ( av && ! IsWhitespace(av->value) );
  299. }
  300.  
  301. /***********************************************************************
  302. * IsPlaceholderAlt
  303. *  
  304. * Checks to see if there is an image and photo place holder contained
  305. * in the ALT text.
  306. *
  307. * Returns 'yes' if there is, 'no' if not.
  308. ***********************************************************************/
  309.  
  310. static Bool IsPlaceholderAlt( ctmbstr txt )
  311. {
  312.     return ( strstr(txt, "image") != NULL || 
  313.              strstr(txt, "photo") != NULL );
  314. }
  315.  
  316.  
  317. /***********************************************************************
  318. * IsPlaceholderTitle
  319. *  
  320. * Checks to see if there is an TITLE place holder contained
  321. * in the 'ALT' text.
  322. *
  323. * Returns 'yes' if there is, 'no' if not.
  324.  
  325. static Bool IsPlaceHolderTitle( ctmbstr txt )
  326. {
  327.     return ( strstr(txt, "title") != NULL );
  328. }
  329. ***********************************************************************/
  330.  
  331.  
  332. /***********************************************************************
  333. * IsPlaceHolderObject
  334. *  
  335. * Checks to see if there is an OBJECT place holder contained
  336. * in the 'ALT' text.
  337. *
  338. * Returns 'yes' if there is, 'no' if not.
  339. ***********************************************************************/
  340.  
  341. static Bool IsPlaceHolderObject( ctmbstr txt )
  342. {
  343.     return ( strstr(txt, "object") != NULL );
  344. }
  345.  
  346.  
  347. /**********************************************************
  348. * EndsWithBytes
  349. *
  350. * Checks to see if the ALT text ends with 'bytes'
  351. * Returns 'yes', if true, 'no' otherwise.
  352. **********************************************************/
  353.  
  354. static Bool EndsWithBytes( ctmbstr txt )
  355. {
  356.     uint len = tmbstrlen( txt );
  357.     return ( len >= 5 && strcmp(txt+len-5, "bytes") == 0 );
  358. }
  359.  
  360.  
  361. /*******************************************************
  362. * textFromOneNode
  363. *
  364. * Returns a list of characters contained within one
  365. * text node.
  366. *******************************************************/
  367.  
  368. static tmbstr textFromOneNode( TidyDocImpl* doc, Node* node )
  369. {
  370.     uint i;
  371.     int x = 0;
  372.     tmbstr txt = doc->access.text;
  373.     
  374.     if ( node )
  375.     {
  376.         /* Copy contents of a text node */
  377.         for (i = node->start; i < node->end; ++i, ++x )
  378.         {
  379.             txt[x] = doc->lexer->lexbuf[i];
  380.  
  381.             /* Check buffer overflow */
  382.             if ( x >= sizeof(doc->access.text)-1 )
  383.                 break;
  384.         }
  385.     }
  386.  
  387.     txt[x] = 0;
  388.     return txt;
  389. }
  390.  
  391.  
  392. /*********************************************************
  393. * getTextNode
  394. *
  395. * Locates text nodes within a container element.
  396. * Retrieves text that are found contained within 
  397. * text nodes, and concatenates the text.
  398. *********************************************************/
  399.     
  400. static void getTextNode( TidyDocImpl* doc, Node* node )
  401. {
  402.     tmbstr txtnod = doc->access.textNode;       
  403.     
  404.     /* 
  405.        Continues to traverse through container element until it no
  406.        longer contains any more contents 
  407.     */
  408.  
  409.     /* If the tag of the node is NULL, then grab the text within the node */
  410.     if ( node && node->type == TextNode )
  411.     {
  412.         uint i;
  413.  
  414.         /* Retrieves each character found within the text node */
  415.         for (i = node->start; i < node->end; i++)
  416.         {
  417.             /* The text must not exceed buffer */
  418.             if ( doc->access.counter >= TEXTBUF_SIZE-1 )
  419.                 return;
  420.  
  421.             txtnod[ doc->access.counter++ ] = doc->lexer->lexbuf[i];
  422.         }
  423.  
  424.         /* Traverses through the contents within a container element */
  425.         for ( node = node->content; node != NULL; node = node->next )
  426.             getTextNode( doc, node );
  427.     }   
  428. }
  429.  
  430.  
  431. /**********************************************************
  432. * getTextNodeClear
  433. *
  434. * Clears the current 'textNode' and reloads it with new
  435. * text.  The textNode must be cleared before use.
  436. **********************************************************/
  437.  
  438. static tmbstr getTextNodeClear( TidyDocImpl* doc, Node* node )
  439. {
  440.     /* Clears list */
  441.     ClearMemory( doc->access.textNode, TEXTBUF_SIZE );
  442.     doc->access.counter = 0;
  443.  
  444.     getTextNode( doc, node );
  445.     return doc->access.textNode;
  446. }
  447.     
  448.  
  449. /********************************************************
  450. * CheckColorAvailable
  451. *
  452. * Verify that information conveyed with color is 
  453. * available without color.
  454. ********************************************************/
  455.  
  456. static void CheckColorAvailable( TidyDocImpl* doc, Node* node )
  457. {
  458.     if ( doc->access.PRIORITYCHK == 1 ||
  459.          doc->access.PRIORITYCHK == 2 ||
  460.          doc->access.PRIORITYCHK == 3 )
  461.     {
  462.         if ( nodeIsIMG(node) )
  463.             ReportAccessWarning( doc, node, INFORMATION_NOT_CONVEYED_IMAGE );
  464.  
  465.         else if ( nodeIsAPPLET(node) )
  466.             ReportAccessWarning( doc, node, INFORMATION_NOT_CONVEYED_APPLET );
  467.  
  468.         else if ( nodeIsOBJECT(node) )
  469.             ReportAccessWarning( doc, node, INFORMATION_NOT_CONVEYED_OBJECT );
  470.  
  471.         else if ( nodeIsSCRIPT(node) )
  472.             ReportAccessWarning( doc, node, INFORMATION_NOT_CONVEYED_SCRIPT );
  473.  
  474.         else if ( nodeIsINPUT(node) )
  475.             ReportAccessWarning( doc, node, INFORMATION_NOT_CONVEYED_INPUT );
  476.     }
  477. }
  478.  
  479. /*********************************************************************
  480. * CheckColorContrast
  481. *
  482. * Checks elements for color contrast.  Must have valid contrast for
  483. * valid visibility.
  484. *
  485. * This logic is extremely fragile as it does not recognize
  486. * the fact that color is inherited by many components and
  487. * that BG and FG colors are often set separately.  E.g. the
  488. * background color may be set by for the body or a table 
  489. * or a cell.  The foreground color may be set by any text
  490. * element (p, h1, h2, input, textarea), either explicitly
  491. * or by style.  Ergo, this test will not handle most real
  492. * world cases.  It's a start, however.
  493. *********************************************************************/
  494.  
  495. static void CheckColorContrast( TidyDocImpl* doc, Node* node )
  496. {
  497.     int rgbBG[3] = {255,255,255};   /* Black text on white BG */
  498.  
  499.     if ( doc->access.PRIORITYCHK == 3 )
  500.     {
  501.         Bool gotBG = yes;
  502.         AttVal* av;
  503.  
  504.         /* Check for 'BGCOLOR' first to compare with other color attributes */
  505.         for ( av = node->attributes; av; av = av->next )
  506.         {            
  507.             if ( attrIsBGCOLOR(av) )
  508.             {
  509.                 if ( hasValue(av) )
  510.                     gotBG = GetRgb( av->value, rgbBG );
  511.             }
  512.         }
  513.         
  514.         /* 
  515.            Search for COLOR attributes to compare with background color
  516.            Must have valid colour contrast
  517.         */
  518.         for ( av = node->attributes; gotBG && av != NULL; av = av->next )
  519.         {
  520.             uint errcode = 0;
  521.             if ( attrIsTEXT(av) )
  522.                 errcode = COLOR_CONTRAST_TEXT;
  523.             else if ( attrIsLINK(av) )
  524.                 errcode = COLOR_CONTRAST_LINK;
  525.             else if ( attrIsALINK(av) )
  526.                 errcode = COLOR_CONTRAST_ACTIVE_LINK;
  527.             else if ( attrIsVLINK(av) )
  528.                 errcode = COLOR_CONTRAST_VISITED_LINK;
  529.  
  530.             if ( errcode && hasValue(av) )
  531.             {
  532.                 int rgbFG[3] = {0, 0, 0};  /* Black text */
  533.  
  534.                 if ( GetRgb(av->value, rgbFG) &&
  535.                      !CompareColors(rgbBG, rgbFG) )
  536.                 {
  537.                     ReportAccessWarning( doc, node, errcode );
  538.                 }
  539.             }
  540.         }
  541.     }
  542. }
  543.  
  544.  
  545. /**************************************************************
  546. * CompareColors
  547. *
  548. * Compares two RGB colors for good contrast.
  549. **************************************************************/
  550. static int minmax( int i1, int i2 )
  551. {
  552.    return MAX(i1, i2) - MIN(i1,i2);
  553. }
  554. static int brightness( int rgb[3] )
  555. {
  556.    return ((rgb[0]*299) + (rgb[1]*587) + (rgb[2]*114)) / 1000;
  557. }
  558.  
  559. static Bool CompareColors( int rgbBG[3], int rgbFG[3] )
  560. {
  561.     int brightBG = brightness( rgbBG );
  562.     int brightFG = brightness( rgbFG );
  563.  
  564.     int diffBright = minmax( brightBG, brightFG );
  565.  
  566.     int diffColor = minmax( rgbBG[0], rgbFG[0] )
  567.                   + minmax( rgbBG[1], rgbFG[1] )
  568.                   + minmax( rgbBG[2], rgbFG[2] );
  569.  
  570.     return ( diffBright > 180 &&
  571.              diffColor > 500 );
  572. }
  573.  
  574.  
  575. /*********************************************************************
  576. * GetRgb
  577. *
  578. * Gets the red, green and blue values for this attribute for the 
  579. * background.
  580. *
  581. * Example: If attribute is BGCOLOR="#121005" then red = 18, green = 16,
  582. * blue = 5.
  583. *********************************************************************/
  584.  
  585. static Bool GetRgb( ctmbstr color, int rgb[] )
  586. {
  587.     int x;
  588.  
  589.     /* Check if we have a color name */
  590.     for (x = 0; x < N_COLORS; x++)
  591.     {
  592.         if ( strstr(colorNames[x], color) != NULL )
  593.         {
  594.             rgb[0] = colorValues[x][0];
  595.             rgb[1] = colorValues[x][1];
  596.             rgb[2] = colorValues[x][2];
  597.             return yes;
  598.         }
  599.     }
  600.  
  601.     /*
  602.        No color name so must be hex values 
  603.        Is this a number in hexadecimal format?
  604.     */
  605.     
  606.     /* Must be 7 characters in the RGB value (including '#') */
  607.     if ( tmbstrlen(color) == 7 && color[0] == '#' )
  608.     {
  609.         rgb[0] = (ctox(color[1]) * 16) + ctox(color[2]);
  610.         rgb[1] = (ctox(color[3]) * 16) + ctox(color[4]);
  611.         rgb[2] = (ctox(color[5]) * 16) + ctox(color[6]);
  612.         return yes;
  613.     }
  614.     return no;
  615. } 
  616.  
  617.  
  618.  
  619. /*******************************************************************
  620. * ctox
  621. *
  622. * Converts a character to a number.
  623. * Example: if given character is 'A' then returns 10.
  624. *
  625. * Returns the number that the character represents. Returns -1 if not a
  626. * valid number.
  627. *******************************************************************/
  628.  
  629. static int ctox( tmbchar ch )
  630. {
  631.     if ( ch >= '0' && ch <= '9' )
  632.     {
  633.          return ch - '0';
  634.     }
  635.     else if ( ch >= 'a' && ch <= 'f' )
  636.     {
  637.         return ch - 'a' + 10;
  638.     }
  639.     else if ( ch >= 'A' && ch <= 'F' )
  640.     {
  641.         return ch - 'A' + 10;
  642.     }
  643.     return -1;
  644. }
  645.  
  646.  
  647. /***********************************************************
  648. * CheckImage
  649. *
  650. * Checks all image attributes for specific elements to
  651. * check for validity of the values contained within
  652. * the attributes.  An appropriate warning message is displayed
  653. * to indicate the error.  
  654. ***********************************************************/
  655.  
  656. static void CheckImage( TidyDocImpl* doc, Node* node )
  657. {
  658.     Bool HasAlt = no;
  659.     Bool HasIsMap = no;
  660.     Bool HasLongDesc = no;
  661.     Bool HasDLINK = no;
  662.     Bool HasValidHeight = no;
  663.     Bool HasValidWidthBullet = no;
  664.     Bool HasValidWidthHR = no; 
  665.     Bool HasTriggeredMissingAlt = no;
  666.     Bool HasTriggeredMissingLongDesc = no;
  667.  
  668.     AttVal* av;
  669.     tmbstr word;
  670.                 
  671.     if ((doc->access.PRIORITYCHK == 1)||
  672.         (doc->access.PRIORITYCHK == 2)||
  673.         (doc->access.PRIORITYCHK == 3))
  674.     {
  675.         /* Checks all image attributes for invalid values within attributes */
  676.         for (av = node->attributes; av != NULL; av = av->next)
  677.         {
  678.             /* 
  679.                Checks for valid ALT attribute.
  680.                The length of the alt text must be less than 150 characters 
  681.                long.
  682.             */
  683.             if ( attrIsALT(av) )
  684.             {
  685.                 if (av->value != NULL) 
  686.                 {
  687.                     if ((tmbstrlen(av->value) < 150) &&
  688.                         (IsPlaceholderAlt (av->value) == no) &&
  689.                         (IsPlaceHolderObject (av->value) == no) &&
  690.                         (EndsWithBytes (av->value) == no) &&
  691.                         (IsImage (av->value) == no))
  692.                     {
  693.                         HasAlt = yes;
  694.                     }
  695.  
  696.                     else if (tmbstrlen (av->value) > 150)
  697.                     {
  698.                         HasAlt = yes;
  699.                         ReportAccessWarning( doc, node, IMG_ALT_SUSPICIOUS_TOO_LONG );
  700.                     }
  701.  
  702.                     else if (IsImage (av->value) == yes)
  703.                     {
  704.                         HasAlt = yes;
  705.                         ReportAccessWarning( doc, node, IMG_ALT_SUSPICIOUS_FILENAME);
  706.                     }
  707.             
  708.                     else if (IsPlaceholderAlt (av->value) == yes)
  709.                     {
  710.                         HasAlt = yes;
  711.                         ReportAccessWarning( doc, node, IMG_ALT_SUSPICIOUS_PLACEHOLDER);
  712.                     }
  713.  
  714.                     else if (EndsWithBytes (av->value) == yes)
  715.                     {
  716.                         HasAlt = yes;
  717.                         ReportAccessWarning( doc, node, IMG_ALT_SUSPICIOUS_FILE_SIZE);
  718.                     }
  719.                 }
  720.             }
  721.  
  722.             /* 
  723.                Checks for width values of 'bullets' and 'horizontal
  724.                rules' for validity.
  725.  
  726.                Valid pixel width for 'bullets' must be < 30, and > 150 for
  727.                horizontal rules.
  728.             */
  729.             else if ( attrIsWIDTH(av) )
  730.             {
  731.                 /* Longdesc attribute needed if width attribute is not present. */
  732.                 if ( hasValue(av) )
  733.                 {
  734.                     int width = atoi( av->value );
  735.                     if ( width < 30 )
  736.                         HasValidWidthBullet = yes;
  737.  
  738.                     if ( width > 150 )
  739.                         HasValidWidthHR = yes;
  740.                 }
  741.             }
  742.  
  743.             /* 
  744.                Checks for height values of 'bullets' and horizontal
  745.                rules for validity.
  746.  
  747.                Valid pixel height for 'bullets' and horizontal rules 
  748.                mustt be < 30.
  749.             */
  750.             else if ( attrIsHEIGHT(av) )
  751.             {
  752.                 /* Longdesc attribute needed if height attribute not present. */
  753.                 if ( hasValue(av) && atoi(av->value) < 30 )
  754.                     HasValidHeight = yes;
  755.             }
  756.  
  757.             /* 
  758.                Checks for longdesc and determines validity.  
  759.                The length of the 'longdesc' must be > 1
  760.             */
  761.             else if ( attrIsLONGDESC(av) )
  762.             {
  763.                 if ( hasValue(av) && tmbstrlen(av->value) > 1 )
  764.                     HasLongDesc = yes;
  765.               }
  766.  
  767.             /* 
  768.                Checks for 'USEMAP' attribute.  Ensures that
  769.                text links are provided for client-side image maps
  770.             */
  771.             else if ( attrIsUSEMAP(av) )
  772.             {
  773.                 if ( hasValue(av) )
  774.                     doc->access.HasUseMap = yes;
  775.             }    
  776.  
  777.             else if ( attrIsISMAP(av) )
  778.             {
  779.                 HasIsMap = yes;
  780.             }
  781.         }    
  782.         
  783.         
  784.         /* 
  785.             Check to see if a dLINK is present.  The ANCHOR element must
  786.             be present following the IMG element.  The text found between 
  787.             the ANCHOR tags must be < 6 characters long, and must contain
  788.             the letter 'd'.
  789.         */
  790.         if ( nodeIsA(node->next) )
  791.         {
  792.             node = node->next;
  793.             
  794.             /* 
  795.                 Node following the anchor must be a text node
  796.                 for dLINK to exist 
  797.             */
  798.  
  799.             if(node->content != NULL && (node->content)->tag == NULL)
  800.             {
  801.                 /* Number of characters found within the text node */
  802.                 word = textFromOneNode( doc, node->content);
  803.                     
  804.                 if ((strcmp(word,"d") == 0)||
  805.                     (strcmp(word,"D") == 0))
  806.                 {
  807.                     HasDLINK = yes;
  808.                 }
  809.             }
  810.         }
  811.                     
  812.         /*
  813.             Special case check for dLINK.  This will occur if there is 
  814.             whitespace between the <img> and <a> elements.  Ignores 
  815.             whitespace and continues check for dLINK.
  816.         */
  817.         
  818.         if ( node->next && !node->next->tag )
  819.         {
  820.             node = node->next;
  821.  
  822.             if ( nodeIsA(node->next) )
  823.             {
  824.                 node = node->next;
  825.  
  826.                 /* 
  827.                     Node following the ANCHOR must be a text node
  828.                     for dLINK to exist 
  829.                 */
  830.                 if(node->content != NULL && node->content->tag == NULL)
  831.                 {
  832.                     /* Number of characters found within the text node */
  833.                     word = textFromOneNode( doc, node->content );
  834.  
  835.                     if ((strcmp(word, "d") == 0)||
  836.                         (strcmp(word, "D") == 0))
  837.                     {
  838.                         HasDLINK = yes;
  839.                     }
  840.                 }
  841.             }    
  842.         }
  843.  
  844.         if ((HasAlt == no)&&
  845.             (HasValidWidthBullet == yes)&&
  846.             (HasValidHeight == yes))
  847.         {
  848.             ReportAccessError( doc, node, IMG_MISSING_ALT_BULLET);
  849.             HasTriggeredMissingAlt = yes;
  850.         }
  851.  
  852.         if ((HasAlt == no)&&
  853.             (HasValidWidthHR == yes)&&
  854.             (HasValidHeight == yes))
  855.         {
  856.             ReportAccessError( doc, node, IMG_MISSING_ALT_H_RULE);
  857.             HasTriggeredMissingAlt = yes;
  858.         }
  859.         
  860.         if (HasTriggeredMissingAlt == no)
  861.         {
  862.             if (HasAlt == no)
  863.             {
  864.                 ReportAccessError( doc, node, IMG_MISSING_ALT);
  865.             }
  866.         }
  867.  
  868.         if ((HasLongDesc == no)&&
  869.             (HasValidHeight ==yes)&&
  870.             (HasValidWidthHR == yes)||
  871.             (HasValidWidthBullet == yes))
  872.         {
  873.             HasTriggeredMissingLongDesc = yes;
  874.             ReportAccessWarning( doc, node, LONGDESC_NOT_REQUIRED);
  875.         }
  876.  
  877.         if (HasTriggeredMissingLongDesc == no)
  878.         {
  879.             if ((HasDLINK == yes)&&
  880.                 (HasLongDesc == no))
  881.             {
  882.                 ReportAccessWarning( doc, node, IMG_MISSING_LONGDESC);
  883.             }
  884.  
  885.             if ((HasLongDesc == yes)&&
  886.                 (HasDLINK == no))
  887.             {
  888.                 ReportAccessWarning( doc, node, IMG_MISSING_DLINK);
  889.             }
  890.             
  891.             if ((HasLongDesc == no)&&
  892.                 (HasDLINK == no))
  893.             {
  894.                 ReportAccessWarning( doc, node, IMG_MISSING_LONGDESC_DLINK);
  895.             }
  896.         }
  897.         
  898.         if (HasIsMap == yes)
  899.         {
  900.             ReportAccessError( doc, node, IMAGE_MAP_SERVER_SIDE_REQUIRES_CONVERSION);
  901.  
  902.             ReportAccessWarning( doc, node, IMG_MAP_SERVER_REQUIRES_TEXT_LINKS);
  903.         }
  904.     }
  905. }
  906.  
  907.  
  908. /***********************************************************
  909. * CheckApplet
  910. *
  911. * Checks APPLET element to check for validity pertaining 
  912. * the 'ALT' attribute.  An appropriate warning message is 
  913. * displayed  to indicate the error. An appropriate warning 
  914. * message is displayed to indicate the error.  If no 'ALT'
  915. * text is present, then there must be alternate content
  916. * within the APPLET element.
  917. ***********************************************************/
  918.  
  919. static void CheckApplet( TidyDocImpl* doc, Node* node )
  920. {
  921.     Bool HasAlt = no;
  922.     Bool HasDescription = no;
  923.  
  924.     AttVal* av;
  925.     tmbstr word = NULL;
  926.         
  927.     if ((doc->access.PRIORITYCHK == 1)||
  928.         (doc->access.PRIORITYCHK == 2)||
  929.         (doc->access.PRIORITYCHK == 3))
  930.     {
  931.         /* Checks for attributes within the APPLET element */
  932.         for (av = node->attributes; av != NULL; av = av->next)
  933.         {
  934.             /*
  935.                Checks for valid ALT attribute.
  936.                The length of the alt text must be > 4 characters in length
  937.                but must be < 150 characters long.
  938.             */
  939.  
  940.             if ( attrIsALT(av) )
  941.             {
  942.                 if (av->value != NULL)
  943.                 {
  944.                     HasAlt = yes;
  945.                 }
  946.             }
  947.         }
  948.  
  949.         if (HasAlt == no)
  950.         {
  951.             /* Must have alternate text representation for that element */
  952.             if (node->content != NULL) 
  953.             {
  954.                 if ( node->content->tag == NULL )
  955.                     word = textFromOneNode( doc, node->content);
  956.  
  957.                 if ( node->content->content != NULL &&
  958.                      node->content->content->tag == NULL )
  959.                 {
  960.                     word = textFromOneNode( doc, node->content->content);
  961.                 }
  962.                 
  963.                 if ( word != NULL && !IsWhitespace(word) )
  964.                     HasDescription = yes;
  965.             }
  966.         }
  967.  
  968.         if ( !HasDescription && !HasAlt )
  969.         {
  970.             ReportAccessError( doc, node, APPLET_MISSING_ALT );
  971.         }
  972.     }
  973. }
  974.  
  975.  
  976. /*******************************************************************
  977. * CheckObject
  978. *
  979. * Checks to verify whether the OBJECT element contains
  980. * 'ALT' text, and to see that the sound file selected is 
  981. * of a valid sound file type.  OBJECT must have an alternate text 
  982. * representation.
  983. *******************************************************************/
  984.  
  985. static void CheckObject( TidyDocImpl* doc, Node* node )
  986. {
  987.     tmbstr word = NULL;
  988.  
  989.     Bool HasAlt = no;
  990.     Bool HasDescription = no;
  991.  
  992.     if ( doc->access.PRIORITYCHK == 1 ||
  993.          doc->access.PRIORITYCHK == 2 ||
  994.          doc->access.PRIORITYCHK == 3 )
  995.     {
  996.         if ( node->content != NULL)
  997.         {
  998.             if ( node->content->type != TextNode )
  999.             {
  1000.                 Node* tnode = node->content;
  1001.                 AttVal* av;
  1002.  
  1003.                 for ( av=tnode->attributes; av; av = av->next )
  1004.                 {
  1005.                     if ( attrIsALT(av) )
  1006.                     {
  1007.                         HasAlt = yes;
  1008.                         break;
  1009.                     }
  1010.                 }
  1011.             }
  1012.  
  1013.             /* Must have alternate text representation for that element */
  1014.             if ( !HasAlt )
  1015.             {
  1016.                 if ( node->content->type == TextNode )
  1017.                     word = textFromOneNode( doc, node->content );
  1018.  
  1019.                 if ( word == NULL && 
  1020.                      node->content->content != NULL &&
  1021.                      node->content->content->type == TextNode )
  1022.                 {
  1023.                     word = textFromOneNode( doc, node->content->content );
  1024.                 }
  1025.                     
  1026.                 if ( word != NULL && !IsWhitespace(word) )
  1027.                     HasDescription = yes;
  1028.             }
  1029.         }
  1030.  
  1031.         if ( !HasAlt && !HasDescription )
  1032.         {
  1033.             ReportAccessError( doc, node, OBJECT_MISSING_ALT );
  1034.         }
  1035.     }
  1036. }
  1037.  
  1038.  
  1039. /***************************************************************
  1040. * CheckMissingStyleSheets
  1041. *
  1042. * Ensures that stylesheets are used to control the presentation.
  1043. ***************************************************************/
  1044.  
  1045. static Bool CheckMissingStyleSheets( TidyDocImpl* doc, Node* node )
  1046. {
  1047.     AttVal* av;
  1048.     Node* content;
  1049.     Bool sspresent = no;
  1050.  
  1051.     for ( content = node->content;
  1052.           !sspresent && content != NULL;
  1053.           content = content->next )
  1054.     {
  1055.         sspresent = ( nodeIsLINK(content)  ||
  1056.                       nodeIsSTYLE(content) ||
  1057.                       nodeIsFONT(content)  ||
  1058.                       nodeIsBASEFONT(content) );
  1059.  
  1060.         for ( av = content->attributes;
  1061.               !sspresent && av != NULL;
  1062.               av = av->next )
  1063.         {
  1064.             sspresent = ( attrIsSTYLE(av) || attrIsTEXT(av)  ||
  1065.                           attrIsVLINK(av) || attrIsALINK(av) ||
  1066.                           attrIsLINK(av) );
  1067.  
  1068.             if ( !sspresent && attrIsREL(av) )
  1069.             {
  1070.                 sspresent = AttrValueIs(av, "stylesheet");
  1071.             }
  1072.         }
  1073.  
  1074.         if ( ! sspresent )
  1075.             sspresent = CheckMissingStyleSheets( doc, content );
  1076.     }
  1077.     return sspresent;
  1078. }
  1079.  
  1080.  
  1081. /*******************************************************************
  1082. * CheckFrame
  1083. *
  1084. * Checks if the URL is valid and to check if a 'LONGDESC' is needed
  1085. * within the FRAME element.  If a 'LONGDESC' is needed, the value must 
  1086. * be valid. The URL must end with the file extension, htm, or html. 
  1087. * Also, checks to ensure that the 'SRC' and 'TITLE' values are valid. 
  1088. *******************************************************************/
  1089.  
  1090. static void CheckFrame( TidyDocImpl* doc, Node* node )
  1091. {
  1092.     Bool HasTitle = no;
  1093.     AttVal* av;
  1094.  
  1095.     doc->access.numFrames++;
  1096.  
  1097.     if ( doc->access.PRIORITYCHK == 1 ||
  1098.          doc->access.PRIORITYCHK == 2 ||
  1099.          doc->access.PRIORITYCHK == 3 )
  1100.     {
  1101.         /* Checks for attributes within the FRAME element */
  1102.         for (av = node->attributes; av != NULL; av = av->next)
  1103.         {
  1104.             /* Checks if 'LONGDESC' value is valid only if present */
  1105.             if ( attrIsLONGDESC(av) )
  1106.             {
  1107.                 if ( hasValue(av) && tmbstrlen(av->value) > 1 )
  1108.                 {
  1109.                     doc->access.HasCheckedLongDesc++;
  1110.                 }
  1111.             }
  1112.  
  1113.             /* Checks for valid 'SRC' value within the frame element */
  1114.             else if ( attrIsSRC(av) )
  1115.             {
  1116.                 if ( hasValue(av) && !IsValidSrcExtension(av->value) )
  1117.                 {
  1118.                     ReportAccessError( doc, node, FRAME_SRC_INVALID );
  1119.                 }
  1120.             }
  1121.  
  1122.             /* Checks for valid 'TITLE' value within frame element */
  1123.             else if ( attrIsTITLE(av) )
  1124.             {
  1125.                 if ( hasValue(av) )
  1126.                     HasTitle = yes;
  1127.  
  1128.                 if ( !HasTitle )
  1129.                 {
  1130.                     if ( av->value == NULL || tmbstrlen(av->value) == 0 )
  1131.                     {
  1132.                         HasTitle = yes;
  1133.                         ReportAccessError( doc, node, FRAME_TITLE_INVALID_NULL);
  1134.                     }
  1135.                     else
  1136.                     {
  1137.                         if ( IsWhitespace(av->value) && tmbstrlen(av->value) > 0 )
  1138.                         {
  1139.                             HasTitle = yes;
  1140.                             ReportAccessError( doc, node, FRAME_TITLE_INVALID_SPACES );
  1141.                         }
  1142.                     }
  1143.                 }
  1144.             }
  1145.         }
  1146.  
  1147.         if ( !HasTitle )
  1148.         {
  1149.             ReportAccessError( doc, node, FRAME_MISSING_TITLE);
  1150.         }
  1151.  
  1152.         if ( doc->access.numFrames==3 && doc->access.HasCheckedLongDesc<3 )
  1153.         {
  1154.             doc->access.numFrames = 0;
  1155.             ReportAccessWarning( doc, node, FRAME_MISSING_LONGDESC );
  1156.         }
  1157.     }
  1158. }
  1159.  
  1160.  
  1161. /****************************************************************
  1162. * CheckIFrame
  1163. *
  1164. * Checks if 'SRC' value is valid.  Must end in appropriate
  1165. * file extension.
  1166. ****************************************************************/
  1167.  
  1168. static void CheckIFrame( TidyDocImpl* doc, Node* node )
  1169. {
  1170.     if ( doc->access.PRIORITYCHK == 1 ||
  1171.          doc->access.PRIORITYCHK == 2 ||
  1172.          doc->access.PRIORITYCHK == 3 )
  1173.     {
  1174.         /* Checks for valid 'SRC' value within the IFRAME element */
  1175.         AttVal* av = attrGetSRC( node );
  1176.         if ( hasValue(av) )
  1177.         {
  1178.             if ( !IsValidSrcExtension(av->value) )
  1179.                 ReportAccessError( doc, node, FRAME_SRC_INVALID );
  1180.         }
  1181.     }
  1182. }
  1183.  
  1184.  
  1185. /**********************************************************************
  1186. * CheckAnchorAccess
  1187. *
  1188. * Checks that the sound file is valid, and to ensure that
  1189. * text transcript is present describing the 'HREF' within the 
  1190. * ANCHOR element.  Also checks to see ensure that the 'TARGET' attribute
  1191. * (if it exists) is not NULL and does not contain '_new' or '_blank'.
  1192. **********************************************************************/
  1193.  
  1194. static void CheckAnchorAccess( TidyDocImpl* doc, Node* node )
  1195. {
  1196.     AttVal* av;
  1197.     tmbstr word = NULL;
  1198.     int checked = 0;
  1199.     Bool HasDescription = no;
  1200.     Bool HasTriggeredLink = no;
  1201.  
  1202.     /* Checks for attributes within the ANCHOR element */
  1203.     for ( av = node->attributes; av != NULL; av = av->next )
  1204.     {
  1205.         if ( doc->access.PRIORITYCHK == 1 ||
  1206.              doc->access.PRIORITYCHK == 2 ||
  1207.              doc->access.PRIORITYCHK == 3 )
  1208.         {
  1209.             /* Must be of valid sound file type */
  1210.             if ( attrIsHREF(av) )
  1211.             {
  1212.                 if ( hasValue(av) )
  1213.                 {
  1214.                     tmbchar ext[ 20 ];
  1215.                     GetFileExtension (av->value, ext, sizeof(ext) );
  1216.  
  1217.                     /* Checks to see if multimedia is used */
  1218.                     if ( IsValidMediaExtension(av->value) )
  1219.                     {
  1220.                         ReportAccessError( doc, node, MULTIMEDIA_REQUIRES_TEXT );
  1221.                     }
  1222.             
  1223.                     /* 
  1224.                         Checks for validity of sound file, and checks to see if 
  1225.                         the file is described within the document, or by a link
  1226.                         that is present which gives the description.
  1227.                     */
  1228.                     if ( tmbstrlen(ext) < 6 && tmbstrlen(ext) > 0 )
  1229.                     {
  1230.                         int errcode = IsSoundFile( av->value );
  1231.                         if ( errcode )
  1232.                         {
  1233.                             if (node->next != NULL)
  1234.                             {
  1235.                                 if (node->next->tag == NULL)
  1236.                                 {
  1237.                                     word = textFromOneNode( doc, node->next);
  1238.                                 
  1239.                                     /* Must contain at least one letter in the text */
  1240.                                     if (IsWhitespace (word) == no)
  1241.                                     {
  1242.                                         HasDescription = yes;
  1243.                                     }
  1244.                                 }
  1245.                             }
  1246.  
  1247.                             /* Must contain text description of sound file */
  1248.                             if ( !HasDescription )
  1249.                             {
  1250.                                 ReportAccessError( doc, node, errcode );
  1251.                             }
  1252.                         }
  1253.                     }
  1254.                 }
  1255.             }
  1256.         }
  1257.  
  1258.         if ( doc->access.PRIORITYCHK == 2 ||
  1259.              doc->access.PRIORITYCHK == 3 )
  1260.         {
  1261.             /* Checks 'TARGET' attribute for validity if it exists */
  1262.             if ( attrIsTARGET(av) )
  1263.             {
  1264.                 checked = 1;
  1265.  
  1266.                 if (AttrValueIs(av, "_new"))
  1267.                 {
  1268.                     ReportAccessWarning( doc, node, NEW_WINDOWS_REQUIRE_WARNING_NEW);
  1269.                 }
  1270.                 else if (AttrValueIs(av, "_blank"))
  1271.                 {
  1272.                     ReportAccessWarning( doc, node, NEW_WINDOWS_REQUIRE_WARNING_BLANK);
  1273.                 }
  1274.             }
  1275.         }
  1276.     }
  1277.     
  1278.     if ( doc->access.PRIORITYCHK == 2 ||
  1279.          doc->access.PRIORITYCHK == 3 )
  1280.     {
  1281.         if ((node->content != NULL)&&
  1282.             (node->content->tag == NULL))
  1283.         {
  1284.             word = textFromOneNode( doc, node->content);
  1285.  
  1286.             if ((word != NULL)&&
  1287.                 (IsWhitespace (word) == no))
  1288.             {
  1289.                 if (strcmp (word, "more") == 0)
  1290.                 {
  1291.                     HasTriggeredLink = yes;
  1292.                     ReportAccessWarning( doc, node, LINK_TEXT_NOT_MEANINGFUL_MORE);
  1293.                 }
  1294.  
  1295.                 if (strcmp (word, "follow this") == 0)
  1296.                 {
  1297.                     ReportAccessWarning( doc, node, LINK_TEXT_NOT_MEANINGFUL_FOLLOW_THIS);
  1298.                 }
  1299.  
  1300.                 if (strcmp (word, "click here") == 0)
  1301.                 {
  1302.                     ReportAccessWarning( doc, node, LINK_TEXT_NOT_MEANINGFUL_CLICK_HERE);
  1303.                 }
  1304.  
  1305.                 if (HasTriggeredLink == no)
  1306.                 {
  1307.                     if (tmbstrlen (word) < 6)
  1308.                     {
  1309.                         ReportAccessWarning( doc, node, LINK_TEXT_NOT_MEANINGFUL);
  1310.                     }
  1311.                 }
  1312.  
  1313.                 if (tmbstrlen (word) > 60)
  1314.                 {
  1315.                     ReportAccessWarning( doc, node, LINK_TEXT_TOO_LONG);
  1316.                 }
  1317.  
  1318.             }
  1319.         }
  1320.         
  1321.         if (node->content == NULL)
  1322.         {
  1323.             ReportAccessWarning( doc, node, LINK_TEXT_MISSING);
  1324.         }
  1325.     }
  1326. }
  1327.  
  1328.  
  1329. /************************************************************
  1330. * CheckArea
  1331. *
  1332. * Checks attributes within the AREA element to 
  1333. * determine if the 'ALT' text and 'HREF' values are valid.
  1334. * Also checks to see ensure that the 'TARGET' attribute
  1335. * (if it exists) is not NULL and does not contain '_new' 
  1336. * or '_blank'.
  1337. ************************************************************/
  1338.  
  1339. static void CheckArea( TidyDocImpl* doc, Node* node )
  1340. {
  1341.     Bool HasAlt = no;
  1342.     AttVal* av;
  1343.  
  1344.     /* Checks all attributes within the AREA element */
  1345.     for (av = node->attributes; av != NULL; av = av->next)
  1346.     {
  1347.         if ((doc->access.PRIORITYCHK == 1)||
  1348.             (doc->access.PRIORITYCHK == 2)||
  1349.             (doc->access.PRIORITYCHK == 3))
  1350.         {
  1351.             /*
  1352.               Checks for valid ALT attribute.
  1353.               The length of the alt text must be > 4 characters long
  1354.               but must be less than 150 characters long.
  1355.             */
  1356.                 
  1357.             if ( attrIsALT(av) )
  1358.             {
  1359.                 /* The check for validity */
  1360.                 if (av->value != NULL) 
  1361.                 {
  1362.                     HasAlt = yes;
  1363.                 }
  1364.             }
  1365.         }
  1366.  
  1367.         if ((doc->access.PRIORITYCHK == 2)||
  1368.             (doc->access.PRIORITYCHK == 3))
  1369.         {
  1370.             if ( attrIsTARGET(av) )
  1371.             {
  1372.                 if (AttrValueIs(av, "_new"))
  1373.                 {
  1374.                     ReportAccessWarning( doc, node, NEW_WINDOWS_REQUIRE_WARNING_NEW);
  1375.                 }
  1376.                 else if (AttrValueIs(av, "_blank"))
  1377.                 {
  1378.                     ReportAccessWarning( doc, node, NEW_WINDOWS_REQUIRE_WARNING_BLANK);
  1379.                 }
  1380.             }
  1381.         }
  1382.     }
  1383.  
  1384.     if ((doc->access.PRIORITYCHK == 1)||
  1385.         (doc->access.PRIORITYCHK == 2)||
  1386.         (doc->access.PRIORITYCHK == 3))
  1387.     {
  1388.         /* AREA must contain alt text */
  1389.         if (HasAlt == no)
  1390.         {
  1391.             ReportAccessError( doc, node, AREA_MISSING_ALT);
  1392.         }    
  1393.     }
  1394. }
  1395.  
  1396.  
  1397. /***************************************************
  1398. * CheckScript
  1399. *
  1400. * Checks the SCRIPT element to ensure that a
  1401. * NOSCRIPT section follows the SCRIPT.  
  1402. ***************************************************/
  1403.  
  1404. static void CheckScriptAcc( TidyDocImpl* doc, Node* node )
  1405. {
  1406.     if ( doc->access.PRIORITYCHK == 1 ||
  1407.          doc->access.PRIORITYCHK == 2 ||
  1408.          doc->access.PRIORITYCHK == 3 )
  1409.     {
  1410.         /* NOSCRIPT element must appear immediately following SCRIPT element */
  1411.         if ( node->next == NULL || !nodeIsNOSCRIPT(node->next) )
  1412.         {
  1413.             ReportAccessError( doc, node, SCRIPT_MISSING_NOSCRIPT);
  1414.         }
  1415.     }
  1416. }
  1417.  
  1418.  
  1419. /**********************************************************
  1420. * CheckRows
  1421. *
  1422. * Check to see that each table has a row of headers if
  1423. * a column of columns doesn't exist. 
  1424. **********************************************************/
  1425.  
  1426. static void CheckRows( TidyDocImpl* doc, Node* node )
  1427. {
  1428.     int numTR = 0;
  1429.     int numValidTH = 0;
  1430.     tmbstr word;
  1431.     
  1432.     doc->access.CheckedHeaders++;
  1433.  
  1434.     for(;;)
  1435.     {
  1436.         if (node == NULL)
  1437.         {
  1438.             break;
  1439.         }
  1440.  
  1441.         else 
  1442.         {
  1443.             numTR++;
  1444.  
  1445.             if ( nodeIsTH(node) )
  1446.             {
  1447.                 doc->access.HasTH = yes;
  1448.             
  1449.                 if ( node->content && nodeIsText(node->content->content) )
  1450.                 {
  1451.                     word = textFromOneNode( doc, node->content->content);
  1452.                     if ( !IsWhitespace(word) )
  1453.                         numValidTH++;
  1454.                 }
  1455.             }
  1456.         }
  1457.         
  1458.         node = node->next;
  1459.     }
  1460.  
  1461.     if (numTR == numValidTH)
  1462.     {
  1463.         doc->access.HasValidRowHeaders = yes;
  1464.     }
  1465.  
  1466.     if ( numTR >= 2 &&
  1467.          numTR > numValidTH &&
  1468.          numValidTH >= 2 &&
  1469.          doc->access.HasTH == yes )
  1470.     {
  1471.         doc->access.HasInvalidRowHeader = yes;
  1472.     }
  1473. }
  1474.  
  1475.  
  1476. /**********************************************************
  1477. * CheckColumns
  1478. *
  1479. * Check to see that each table has a column of headers if
  1480. * a row of columns doesn't exist.  
  1481. **********************************************************/
  1482.  
  1483. static void CheckColumns( TidyDocImpl* doc, Node* node )
  1484. {
  1485.     Node* tnode;
  1486.     tmbstr word;
  1487.     int numTH = 0;
  1488.     Bool isMissingHeader = no;
  1489.  
  1490.     doc->access.CheckedHeaders++;
  1491.  
  1492.     /* Table must have row of headers if headers for columns don't exist */
  1493.     if ( nodeIsTH(node->content) )
  1494.     {
  1495.         doc->access.HasTH = yes;
  1496.  
  1497.         for ( tnode = node->content; tnode; tnode = tnode->next )
  1498.         {
  1499.             if ( nodeIsTH(tnode) )
  1500.             {
  1501.                 if ( nodeIsText(tnode->content) )
  1502.                 {
  1503.                     word = textFromOneNode( doc, tnode->content);
  1504.                     if ( !IsWhitespace(word) )
  1505.                         numTH++;
  1506.                 }
  1507.             }
  1508.             else
  1509.             {
  1510.                 isMissingHeader = yes;
  1511.             }
  1512.         }
  1513.     }
  1514.  
  1515.     if ( !isMissingHeader && numTH > 0 )
  1516.         doc->access.HasValidColumnHeaders = yes;
  1517.  
  1518.     if ( isMissingHeader && numTH >= 2 )
  1519.         doc->access.HasInvalidColumnHeader = yes;
  1520. }
  1521.  
  1522.  
  1523. /*****************************************************
  1524. * CheckTH
  1525. *
  1526. * Checks to see if the header provided for a table
  1527. * requires an abbreviation. (only required if the 
  1528. * length of the header is greater than 15 characters)
  1529. *****************************************************/
  1530.  
  1531. static void CheckTH( TidyDocImpl* doc, Node* node )
  1532. {
  1533.     Bool HasAbbr = no;
  1534.     tmbstr word = NULL;
  1535.     AttVal* av;
  1536.  
  1537.     if (doc->access.PRIORITYCHK == 3)
  1538.     {
  1539.         /* Checks TH element for 'ABBR' attribute */
  1540.         for (av = node->attributes; av != NULL; av = av->next)
  1541.         {
  1542.             if ( attrIsABBR(av) )
  1543.             {
  1544.                 /* Value must not be NULL and must be less than 15 characters */
  1545.                 if ((av->value != NULL)&&
  1546.                     (IsWhitespace (av->value) == no))
  1547.                 {
  1548.                     HasAbbr = yes;
  1549.                 }
  1550.  
  1551.                 if ((av->value == NULL)||
  1552.                     (tmbstrlen (av->value) == 0))
  1553.                 {
  1554.                     HasAbbr = yes;
  1555.                     ReportAccessWarning( doc, node, TABLE_MAY_REQUIRE_HEADER_ABBR_NULL);
  1556.                 }
  1557.                 
  1558.                 if ((IsWhitespace (av->value) == yes)&&
  1559.                     (tmbstrlen (av->value) > 0))
  1560.                 {
  1561.                     HasAbbr = yes;
  1562.                     ReportAccessWarning( doc, node, TABLE_MAY_REQUIRE_HEADER_ABBR_SPACES);
  1563.                 }
  1564.             }
  1565.         }
  1566.  
  1567.         /* If the header is greater than 15 characters, an abbreviation is needed */
  1568.         word = textFromOneNode( doc, node->content);
  1569.  
  1570.         if ((word != NULL)&&
  1571.             (IsWhitespace (word) == no))
  1572.         {
  1573.             /* Must have 'ABBR' attribute if header is > 15 characters */
  1574.             if ((tmbstrlen (word) > 15)&&
  1575.                 (HasAbbr == no))
  1576.             {
  1577.                 ReportAccessWarning( doc, node, TABLE_MAY_REQUIRE_HEADER_ABBR);
  1578.             }
  1579.         }
  1580.     }
  1581. }
  1582.  
  1583.  
  1584. /*****************************************************************
  1585. * CheckMultiHeaders
  1586. *
  1587. * Layout tables should make sense when linearized.
  1588. * TABLE must contain at least one TH element.
  1589. * This technique applies only to tables used for layout purposes, 
  1590. * not to data tables. Checks for column of multiple headers.
  1591. *****************************************************************/
  1592.  
  1593. static void CheckMultiHeaders( TidyDocImpl* doc, Node* node )
  1594. {
  1595.     Node* TNode;
  1596.     Node* temp;
  1597.     
  1598.     Bool validColSpanRows = yes;
  1599.     Bool validColSpanColumns = yes;
  1600.  
  1601.     int flag = 0;
  1602.  
  1603.     if ( doc->access.PRIORITYCHK == 1 ||
  1604.          doc->access.PRIORITYCHK == 2 ||
  1605.          doc->access.PRIORITYCHK == 3 )
  1606.     {
  1607.         if (node->content != NULL)
  1608.         {
  1609.             TNode = node->content;
  1610.  
  1611.             /* 
  1612.                Checks for column of multiple headers found 
  1613.                within a data table. 
  1614.             */
  1615.             while (TNode != NULL)
  1616.             {
  1617.                 if ( nodeIsTR(TNode) )
  1618.                 {
  1619.                     if (TNode->content != NULL)
  1620.                     {
  1621.                         temp = TNode->content;
  1622.  
  1623.                         if ( nodeIsTH(temp) )
  1624.                         {
  1625.                             AttVal* av;
  1626.                             for (av = temp->attributes; av != NULL; av = av->next)
  1627.                             {
  1628.                                 if ( attrIsROWSPAN(av) )
  1629.                                 {
  1630.                                     if (atoi(av->value) > 1)
  1631.                                     {
  1632.                                         validColSpanRows = no;
  1633.                                     }
  1634.                                 }
  1635.                             }
  1636.                         }
  1637.  
  1638.                         /* The number of TH elements found within TR element */
  1639.                         if (flag == 0)
  1640.                         {
  1641.                             while (temp != NULL)
  1642.                             {
  1643.                                 /* 
  1644.                                    Must contain at least one TH element 
  1645.                                    within in the TR element 
  1646.                                 */
  1647.                                 if ( nodeIsTH(temp) )
  1648.                                 {
  1649.                                     AttVal* av;
  1650.                                     for (av = temp->attributes; av != NULL; av = av->next)
  1651.                                     {
  1652.                                         if ( attrIsCOLSPAN(av) )
  1653.                                         {
  1654.                                             if (atoi(av->value) > 1)
  1655.                                             {
  1656.                                                 validColSpanColumns = no;
  1657.                                             }
  1658.                                         }
  1659.                                     }
  1660.                                 }
  1661.  
  1662.                                 temp = temp->next;
  1663.                             }    
  1664.  
  1665.                             flag = 1;
  1666.                         }
  1667.                     }
  1668.                 }
  1669.             
  1670.                 TNode = TNode->next;
  1671.             }
  1672.  
  1673.             /* Displays HTML 4 Table Algorithm when multiple column of headers used */
  1674.             if (validColSpanRows == no)
  1675.             {
  1676.                 ReportAccessWarning( doc, node, DATA_TABLE_REQUIRE_MARKUP_ROW_HEADERS );
  1677.                 DisplayHTMLTableAlgorithm( doc );
  1678.             }
  1679.  
  1680.             if (validColSpanColumns == no)
  1681.             {
  1682.                 ReportAccessWarning( doc, node, DATA_TABLE_REQUIRE_MARKUP_COLUMN_HEADERS );
  1683.                 DisplayHTMLTableAlgorithm( doc );
  1684.             }
  1685.         }
  1686.     }
  1687. }
  1688.  
  1689.  
  1690. /****************************************************
  1691. * CheckTable
  1692. *
  1693. * Checks the TABLE element to ensure that the
  1694. * table is not missing any headers.  Must have either
  1695. * a row or column of headers.  
  1696. ****************************************************/
  1697.  
  1698. static void CheckTable( TidyDocImpl* doc, Node* node )
  1699. {
  1700.     Node* TNode;
  1701.     Node* temp;
  1702.  
  1703.     tmbstr word = NULL;
  1704.  
  1705.     int numTR = 0;
  1706.  
  1707.     Bool HasSummary = no;
  1708.     Bool HasCaption = no;
  1709.  
  1710.     if (doc->access.PRIORITYCHK == 3)
  1711.     {
  1712.         AttVal* av;
  1713.         /* Table must have a 'SUMMARY' describing the purpose of the table */
  1714.         for (av = node->attributes; av != NULL; av = av->next)
  1715.         {
  1716.             if ( attrIsSUMMARY(av) )
  1717.             {
  1718.                 if ( hasValue(av) )
  1719.                 {
  1720.                     if (!AttrContains(av, "summary") && 
  1721.                         !AttrContains(av, "table"))
  1722.                     {
  1723.                         HasSummary = yes;
  1724.                     }
  1725.  
  1726.                     if (AttrContains(av, "summary") && 
  1727.                         AttrContains(av, "table"))
  1728.                     {
  1729.                         HasSummary = yes;
  1730.                         ReportAccessError( doc, node, TABLE_SUMMARY_INVALID_PLACEHOLDER );
  1731.                     }
  1732.                 }
  1733.  
  1734.                 if ( av->value == NULL || tmbstrlen(av->value) == 0 )
  1735.                 {
  1736.                     HasSummary = yes;
  1737.                     ReportAccessError( doc, node, TABLE_SUMMARY_INVALID_NULL );
  1738.                 }
  1739.                 else if ( IsWhitespace(av->value) && tmbstrlen(av->value) > 0 )
  1740.                 {
  1741.                     HasSummary = yes;
  1742.                     ReportAccessError( doc, node, TABLE_SUMMARY_INVALID_SPACES );
  1743.                 }
  1744.             }
  1745.         }
  1746.  
  1747.         /* TABLE must have content. */
  1748.         if (node->content == NULL)
  1749.         {
  1750.             ReportAccessError( doc, node, DATA_TABLE_MISSING_HEADERS);
  1751.         
  1752.             return;
  1753.         }
  1754.     }
  1755.  
  1756.     if ((doc->access.PRIORITYCHK == 1)||
  1757.         (doc->access.PRIORITYCHK == 2)||
  1758.         (doc->access.PRIORITYCHK == 3))
  1759.     {
  1760.         /* Checks for multiple headers */
  1761.         CheckMultiHeaders( doc, node );
  1762.     }
  1763.     
  1764.     if ((doc->access.PRIORITYCHK == 2)||
  1765.         (doc->access.PRIORITYCHK == 3))
  1766.     {
  1767.         /* Table must have a CAPTION describing the purpose of the table */
  1768.         if ( nodeIsCAPTION(node->content) )
  1769.         {
  1770.             TNode = node->content;
  1771.  
  1772.             if (TNode->content->tag == NULL)
  1773.             {
  1774.                 word = getTextNodeClear( doc, TNode);
  1775.             }
  1776.  
  1777.             if ( !IsWhitespace(word) )
  1778.             {
  1779.                 HasCaption = yes;
  1780.             }
  1781.         }
  1782.  
  1783.         if (HasCaption == no)
  1784.         {
  1785.             ReportAccessError( doc, node, TABLE_MISSING_CAPTION);
  1786.         }
  1787.     }
  1788.  
  1789.     
  1790.     if (node->content != NULL)
  1791.     {
  1792.         if ( nodeIsCAPTION(node->content) && nodeIsTR(node->content->next) )
  1793.         {
  1794.             CheckColumns( doc, node->content->next );
  1795.         }
  1796.         else if ( nodeIsTR(node->content) )
  1797.         {
  1798.             CheckColumns( doc, node->content );
  1799.         }
  1800.     }
  1801.     
  1802.     if ( ! doc->access.HasValidColumnHeaders )
  1803.     {
  1804.         if (node->content != NULL)
  1805.         {
  1806.             if ( nodeIsCAPTION(node->content) && nodeIsTR(node->content->next) )
  1807.             {
  1808.                 CheckRows( doc, node->content->next);
  1809.             }
  1810.             else if ( nodeIsTR(node->content) )
  1811.             {
  1812.                 CheckRows( doc, node->content);
  1813.             }
  1814.         }
  1815.     }
  1816.     
  1817.     
  1818.     if ( doc->access.PRIORITYCHK == 3 )
  1819.     {
  1820.         /* Suppress warning for missing 'SUMMARY for HTML 2.0 and HTML 3.2 */
  1821.         if (HasSummary == no)
  1822.         {
  1823.             ReportAccessError( doc, node, TABLE_MISSING_SUMMARY);
  1824.         }
  1825.     }
  1826.  
  1827.     if ( doc->access.PRIORITYCHK == 2 ||
  1828.          doc->access.PRIORITYCHK == 3 )
  1829.     {
  1830.         if (node->content != NULL)
  1831.         {
  1832.             temp = node->content;
  1833.  
  1834.             while (temp != NULL)
  1835.             {
  1836.                 if ( nodeIsTR(temp) )
  1837.                 {
  1838.                     numTR++;
  1839.                 }
  1840.  
  1841.                 temp = temp->next;
  1842.             }
  1843.  
  1844.             if (numTR == 1)
  1845.             {
  1846.                 ReportAccessWarning( doc, node, LAYOUT_TABLES_LINEARIZE_PROPERLY);
  1847.             }
  1848.         }
  1849.     
  1850.         if ( doc->access.HasTH )
  1851.         {
  1852.             ReportAccessWarning( doc, node, LAYOUT_TABLE_INVALID_MARKUP);
  1853.         }
  1854.     }
  1855.  
  1856.     if ( doc->access.PRIORITYCHK == 1 ||
  1857.          doc->access.PRIORITYCHK == 2 ||
  1858.          doc->access.PRIORITYCHK == 3 )
  1859.     {
  1860.         if ( doc->access.CheckedHeaders == 2 )
  1861.         {
  1862.             if ( !doc->access.HasValidRowHeaders &&
  1863.                  !doc->access.HasValidColumnHeaders &&
  1864.                  !doc->access.HasInvalidRowHeader &&
  1865.                  !doc->access.HasInvalidColumnHeader  )
  1866.             {
  1867.                 ReportAccessError( doc, node, DATA_TABLE_MISSING_HEADERS);
  1868.             }
  1869.  
  1870.             if ( !doc->access.HasValidRowHeaders && 
  1871.                  doc->access.HasInvalidRowHeader )
  1872.             {
  1873.                 ReportAccessError( doc, node, DATA_TABLE_MISSING_HEADERS_ROW);
  1874.             }
  1875.  
  1876.             if ( !doc->access.HasValidColumnHeaders &&
  1877.                  doc->access.HasInvalidColumnHeader )
  1878.             {
  1879.                 ReportAccessError( doc, node, DATA_TABLE_MISSING_HEADERS_COLUMN);
  1880.             }
  1881.         }
  1882.     }
  1883. }
  1884.  
  1885.  
  1886. /***************************************************
  1887. * CheckASCII
  1888. * 
  1889. * Checks for valid text equivalents for XMP and PRE
  1890. * elements for ASCII art.  Ensures that there is
  1891. * a skip over link to skip multi-lined ASCII art.
  1892. ***************************************************/
  1893.  
  1894. static void CheckASCII( TidyDocImpl* doc, Node* node )
  1895. {
  1896.     Node* temp1;
  1897.     Node* temp2;
  1898.  
  1899.     tmbstr skipOver = NULL;
  1900.     Bool IsAscii = no;
  1901.     int HasSkipOverLink = 0;
  1902.         
  1903.     uint i, x;
  1904.     int newLines = -1;
  1905.     tmbchar compareLetter;
  1906.     int matchingCount = 0;
  1907.     AttVal* av;
  1908.     
  1909.     if ( doc->access.PRIORITYCHK == 1 ||
  1910.          doc->access.PRIORITYCHK == 2 ||
  1911.          doc->access.PRIORITYCHK == 3 )
  1912.     {
  1913.         /* 
  1914.            Checks the text within the PRE and XMP tags to see if ascii 
  1915.            art is present 
  1916.         */
  1917.         for (i = node->content->start + 1; i < node->content->end; i++)
  1918.         {
  1919.             matchingCount = 0;
  1920.  
  1921.             /* Counts the number of lines of text */
  1922.             if (doc->lexer->lexbuf[i] == '\n')
  1923.             {
  1924.                 newLines++;
  1925.             }
  1926.             
  1927.             compareLetter = doc->lexer->lexbuf[i];
  1928.  
  1929.             /* Counts consecutive character matches */
  1930.             for (x = i; x < i + 5; x++)
  1931.             {
  1932.                 if (doc->lexer->lexbuf[x] == compareLetter)
  1933.                 {
  1934.                     matchingCount++;
  1935.                 }
  1936.  
  1937.                 else
  1938.                 {
  1939.                     break;
  1940.                 }
  1941.             }
  1942.  
  1943.             /* Must have at least 5 consecutive character matches */
  1944.             if (matchingCount >= 5)
  1945.             {
  1946.                 break;
  1947.             }
  1948.         }
  1949.  
  1950.         /* 
  1951.            Must have more than 6 lines of text OR 5 or more consecutive 
  1952.            letters that are the same for there to be ascii art 
  1953.         */
  1954.         if (newLines >= 6 || matchingCount >= 5)
  1955.         {
  1956.             IsAscii = yes;
  1957.         }
  1958.  
  1959.         /* Checks for skip over link if ASCII art is present */
  1960.         if (IsAscii == yes)
  1961.         {
  1962.             if (node->prev != NULL && node->prev->prev != NULL)
  1963.             {
  1964.                 temp1 = node->prev->prev;
  1965.  
  1966.                 /* Checks for 'HREF' attribute */
  1967.                 for (av = temp1->attributes; av != NULL; av = av->next)
  1968.                 {
  1969.                     if ( attrIsHREF(av) && hasValue(av) )
  1970.                     {
  1971.                         skipOver = av->value;
  1972.                         HasSkipOverLink++;
  1973.                     }
  1974.                 }
  1975.             }
  1976.         }
  1977.     }
  1978.  
  1979.     if ((doc->access.PRIORITYCHK == 2)||
  1980.         (doc->access.PRIORITYCHK == 3))
  1981.     {
  1982.         /* 
  1983.            Checks for A element following PRE to ensure proper skipover link
  1984.            only if there is an A element preceding PRE.
  1985.         */
  1986.         if (HasSkipOverLink == 1)
  1987.         {
  1988.             if ( nodeIsA(node->next) )
  1989.             {
  1990.                 temp2 = node->next;
  1991.                 
  1992.                 /* Checks for 'NAME' attribute */
  1993.                 for (av = temp2->attributes; av != NULL; av = av->next)
  1994.                 {
  1995.                     if ( attrIsNAME(av) && hasValue(av) )
  1996.                     {
  1997.                         /* 
  1998.                            Value within the 'HREF' attribute must be the same
  1999.                            as the value within the 'NAME' attribute for valid
  2000.                            skipover.
  2001.                         */
  2002.                         if ( strstr(skipOver, av->value) != NULL )
  2003.                         {
  2004.                             HasSkipOverLink++;
  2005.                         }
  2006.                     }
  2007.                 }
  2008.             }
  2009.         }
  2010.  
  2011.         if (IsAscii == yes)
  2012.         {
  2013.             ReportAccessError( doc, node, ASCII_REQUIRES_DESCRIPTION);
  2014.         }
  2015.  
  2016.         if (HasSkipOverLink < 2)
  2017.         {
  2018.             if (IsAscii == yes)
  2019.             {
  2020.                 ReportAccessError( doc, node, SKIPOVER_ASCII_ART);
  2021.             }
  2022.         }
  2023.     }
  2024. }
  2025.  
  2026.  
  2027. /***********************************************************
  2028. * CheckFormControls
  2029. *
  2030. * <form> must have valid 'FOR' attribute, and <label> must
  2031. * have valid 'ID' attribute for valid form control.
  2032. ***********************************************************/
  2033.  
  2034. static void CheckFormControls( TidyDocImpl* doc, Node* node )
  2035. {
  2036.     if ( !doc->access.HasValidFor &&
  2037.          doc->access.HasValidId )
  2038.     {
  2039.         ReportAccessError( doc, node, ASSOCIATE_LABELS_EXPLICITLY_FOR);
  2040.     }    
  2041.  
  2042.     if ( !doc->access.HasValidId &&
  2043.          doc->access.HasValidFor )
  2044.     {
  2045.         ReportAccessError( doc, node, ASSOCIATE_LABELS_EXPLICITLY_ID);
  2046.     }
  2047.  
  2048.     if ( !doc->access.HasValidId &&
  2049.          !doc->access.HasValidFor )
  2050.     {
  2051.         ReportAccessError( doc, node, ASSOCIATE_LABELS_EXPLICITLY);
  2052.     }
  2053. }
  2054.  
  2055.  
  2056. /************************************************************
  2057. * CheckLabel
  2058. *
  2059. * Check for valid 'FOR' attribute within the LABEL element
  2060. ************************************************************/
  2061.  
  2062. static void CheckLabel( TidyDocImpl* doc, Node* node )
  2063. {
  2064.     if ( doc->access.PRIORITYCHK == 2 ||
  2065.          doc->access.PRIORITYCHK == 3 )
  2066.     {    
  2067.         /* Checks for valid 'FOR' attribute */
  2068.         AttVal* av = attrGetFOR( node );
  2069.         if ( hasValue(av) )
  2070.             doc->access.HasValidFor = yes;
  2071.  
  2072.         if ( ++doc->access.ForID == 2 )
  2073.         {
  2074.             doc->access.ForID = 0;
  2075.             CheckFormControls( doc, node );
  2076.         }
  2077.     }
  2078. }
  2079.  
  2080.  
  2081. /************************************************************
  2082. * CheckInputLabel
  2083. * 
  2084. * Checks for valid 'ID' attribute within the INPUT element.
  2085. * Checks to see if there is a LABEL directly before
  2086. * or after the INPUT element determined by the 'TYPE'.  
  2087. * Each INPUT element must have a LABEL describing the form.
  2088. ************************************************************/
  2089.  
  2090. static void CheckInputLabel( TidyDocImpl* doc, Node* node )
  2091. {
  2092.     int flag = 0;
  2093.  
  2094.     tmbstr word = NULL;
  2095.     tmbstr text = NULL;
  2096.  
  2097.     AttVal* av;
  2098.  
  2099.     Bool HasLabelBefore = no;
  2100.     Bool HasLabelAfter = no;
  2101.     Bool HasValidLabel = no;
  2102.  
  2103.     if ( doc->access.PRIORITYCHK == 2 ||
  2104.          doc->access.PRIORITYCHK == 3 )
  2105.     {
  2106.  
  2107.         /* Checks attributes within the INPUT element */
  2108.         for (av = node->attributes; av != NULL; av = av->next)
  2109.         {
  2110.             /* Must have valid 'ID' value */
  2111.             if ( attrIsID(av) && hasValue(av) )
  2112.                 doc->access.HasValidId = yes;
  2113.     
  2114.             /* 
  2115.                Determines where the LABEL should be located determined by 
  2116.                the 'TYPE' of form the INPUT is.
  2117.             */
  2118.             else if ( attrIsTYPE(av) && hasValue(av) )
  2119.             {
  2120.                 if (AttrValueIs(av, "checkbox") ||
  2121.                     AttrValueIs(av, "radio")    ||
  2122.                     AttrValueIs(av, "text")     ||
  2123.                     AttrValueIs(av, "password") ||
  2124.                     AttrValueIs(av, "file"))
  2125.                 {
  2126.                     if ( node->prev != NULL &&
  2127.                          node->prev->prev != NULL )
  2128.                     {
  2129.                         Node* temp = node->prev->prev;
  2130.                         if ( nodeIsLABEL(temp) )
  2131.                         {
  2132.                             flag = 1;
  2133.                             if ( nodeIsText(temp->content) )
  2134.                             {
  2135.                                 word = textFromOneNode( doc, temp->content );
  2136.                                 if ( !IsWhitespace(word) )
  2137.                                     HasLabelBefore = yes;
  2138.                             }
  2139.                         }
  2140.                         
  2141.                         if ( HasLabelBefore && nodeIsText(node->prev) )
  2142.                         {
  2143.                             text = textFromOneNode( doc, node->prev );
  2144.                             if ( IsWhitespace(text) )
  2145.                                 HasValidLabel = yes;
  2146.                         }
  2147.                     }
  2148.  
  2149.                     if ( flag == 0 )
  2150.                     {
  2151.                         if ( node->next != NULL &&
  2152.                              node->next->next != NULL )
  2153.                         {
  2154.                             Node* temp = node->next->next;
  2155.                             if ( nodeIsLABEL(temp) &&
  2156.                                  nodeIsText(temp->content) )
  2157.                             {
  2158.                                 word = textFromOneNode( doc, temp->content);
  2159.                                 if ( !IsWhitespace(word) )
  2160.                                     HasLabelAfter = yes;
  2161.                             }
  2162.  
  2163.                             if ( HasLabelAfter && nodeIsText(node->next) )
  2164.                             {
  2165.                                 text = textFromOneNode( doc, node->next);
  2166.                                 if ( IsWhitespace(text) )
  2167.                                     HasValidLabel = yes;
  2168.                             }
  2169.                         }
  2170.                     }
  2171.                 }
  2172.  
  2173.                 /* The following 'TYPES' do not require a LABEL */
  2174.                 if (AttrValueIs(av, "image")  ||
  2175.                     AttrValueIs(av, "submit") ||
  2176.                     AttrValueIs(av, "reset")  ||
  2177.                     AttrValueIs(av, "button"))
  2178.                 {
  2179.                     HasValidLabel = yes;
  2180.                 }
  2181.             }
  2182.         }
  2183.  
  2184.         if ( !HasValidLabel )
  2185.         {
  2186.             if ( HasLabelBefore )
  2187.               ReportAccessError( doc, node, LABEL_NEEDS_REPOSITIONING_BEFORE_INPUT );
  2188.        
  2189.             if ( HasLabelAfter )
  2190.               ReportAccessError( doc, node, LABEL_NEEDS_REPOSITIONING_AFTER_INPUT );
  2191.         }
  2192.         
  2193.         if ( ++doc->access.ForID == 2 )
  2194.         {
  2195.             doc->access.ForID = 0;
  2196.             CheckFormControls( doc, node );
  2197.         }
  2198.     }
  2199. }
  2200.  
  2201.  
  2202. /***************************************************************
  2203. * CheckInputAttributes 
  2204. *
  2205. * INPUT element must have a valid 'ALT' attribute if the
  2206. * 'VALUE' attribute is present.
  2207. ***************************************************************/
  2208.  
  2209. static void CheckInputAttributes( TidyDocImpl* doc, Node* node )
  2210. {
  2211.     Bool HasValue = no;
  2212.     Bool HasAlt = no;
  2213.     Bool MustHaveAlt = no;
  2214.     Bool MustHaveValue = no;
  2215.     AttVal* av;
  2216.  
  2217.     /* Checks attributes within the INPUT element */
  2218.     for (av = node->attributes; av != NULL; av = av->next)
  2219.     {
  2220.         /* 'VALUE' must be found if the 'TYPE' is 'text' or 'checkbox' */
  2221.         if ( attrIsTYPE(av) && hasValue(av) )
  2222.         {
  2223.             if ( doc->access.PRIORITYCHK == 1 ||
  2224.                  doc->access.PRIORITYCHK == 2 ||
  2225.                  doc->access.PRIORITYCHK == 3 )
  2226.             {
  2227.                 if (AttrValueIs(av, "image"))
  2228.                 {
  2229.                     MustHaveAlt = yes;
  2230.                 }
  2231.             }
  2232.  
  2233.             if ( doc->access.PRIORITYCHK == 3 )
  2234.             {
  2235.                 if (AttrValueIs(av, "text") ||
  2236.                     AttrValueIs(av, "checkbox"))
  2237.                 {    
  2238.                     MustHaveValue = yes;
  2239.                 }
  2240.             }
  2241.         }
  2242.         
  2243.         if ( attrIsALT(av) && hasValue(av) )
  2244.         {
  2245.             HasAlt = yes;
  2246.         }
  2247.  
  2248.         if ( attrIsVALUE(av) )
  2249.         {
  2250.             if ( hasValue(av) )
  2251.             {
  2252.                 HasValue = yes;
  2253.             }
  2254.             else if ( av->value == NULL || tmbstrlen(av->value) == 0 )
  2255.             {
  2256.                 HasValue = yes;
  2257.                 ReportAccessError( doc, node, FORM_CONTROL_DEFAULT_TEXT_INVALID_NULL );
  2258.             }
  2259.             else if ( IsWhitespace(av->value) && tmbstrlen(av->value) > 0 )
  2260.             {
  2261.                 HasValue = yes;
  2262.                 ReportAccessError( doc, node, FORM_CONTROL_DEFAULT_TEXT_INVALID_SPACES );
  2263.             }
  2264.         }
  2265.     }
  2266.  
  2267.     if ( MustHaveAlt && !HasAlt )
  2268.     {
  2269.         ReportAccessError( doc, node, IMG_BUTTON_MISSING_ALT );
  2270.     }
  2271.  
  2272.     if ( MustHaveValue && !HasValue )
  2273.     {
  2274.         ReportAccessError( doc, node, FORM_CONTROL_REQUIRES_DEFAULT_TEXT );
  2275.     }
  2276. }
  2277.  
  2278.  
  2279. /***************************************************************
  2280. * CheckFrameSet
  2281. *
  2282. * Frameset must have valid NOFRAME section.  Must contain some 
  2283. * text but must not contain information telling user to update 
  2284. * browsers, 
  2285. ***************************************************************/
  2286.  
  2287. static void CheckFrameSet( TidyDocImpl* doc, Node* node )
  2288. {
  2289.     Node* temp;
  2290.     tmbstr word;
  2291.     
  2292.     Bool HasNoFrames = no;
  2293.  
  2294.     if ((doc->access.PRIORITYCHK == 1)||
  2295.         (doc->access.PRIORITYCHK == 2)||
  2296.         (doc->access.PRIORITYCHK == 3))
  2297.     {
  2298.         if (node->content != NULL)
  2299.         {
  2300.             temp = node->content;
  2301.  
  2302.             while (temp != NULL)
  2303.             {
  2304.                 if ( nodeIsA(temp) )
  2305.                 {
  2306.                     ReportAccessError( doc, temp, NOFRAMES_INVALID_LINK);
  2307.                 }
  2308.                 else if ( nodeIsNOFRAMES(temp) )
  2309.                 {
  2310.                     HasNoFrames = yes;
  2311.  
  2312.                     if ( temp->content && nodeIsP(temp->content->content) )
  2313.                     {
  2314.                         Node* para = temp->content->content;
  2315.                         if ( nodeIsText(para->content) )
  2316.                         {
  2317.                             word = textFromOneNode( doc, para->content );
  2318.                             if ( word && strstr(word, "browser") != NULL )
  2319.                             {
  2320.                                 ReportAccessError( doc, para, NOFRAMES_INVALID_CONTENT );
  2321.                             }
  2322.                         }
  2323.                     }
  2324.                     else if (temp->content == NULL)
  2325.                     {
  2326.                         ReportAccessError( doc, temp, NOFRAMES_INVALID_NO_VALUE);
  2327.                     }
  2328.                     else if ( temp->content &&
  2329.                               IsWhitespace(textFromOneNode(doc, temp->content)) )
  2330.                     {
  2331.                         ReportAccessError( doc, temp, NOFRAMES_INVALID_NO_VALUE);
  2332.                     }
  2333.                 }
  2334.  
  2335.                 temp = temp->next;
  2336.             }
  2337.         }
  2338.  
  2339.         if (HasNoFrames == no)
  2340.         {
  2341.             ReportAccessError( doc, node, FRAME_MISSING_NOFRAMES);
  2342.         }
  2343.     }
  2344. }
  2345.  
  2346.  
  2347. /***********************************************************
  2348. * CheckHeaderNesting
  2349. *
  2350. * Checks for heading increases and decreases.  Headings must
  2351. * not increase by more than one header level, but may
  2352. * decrease at from any level to any level.  Text within 
  2353. * headers must not be more than 20 words in length.  
  2354. ***********************************************************/
  2355.  
  2356. static void CheckHeaderNesting( TidyDocImpl* doc, Node* node )
  2357. {
  2358.     Node* temp;
  2359.     tmbstr word;
  2360.     uint i;
  2361.     int numWords = 1;
  2362.  
  2363.     Bool IsValidIncrease = no;
  2364.     Bool NeedsDescription = no;
  2365.  
  2366.     if ( doc->access.PRIORITYCHK == 2 ||
  2367.          doc->access.PRIORITYCHK == 3 )
  2368.     {
  2369.         /* 
  2370.            Text within header element cannot contain more than 20 words without
  2371.            a separate description
  2372.         */
  2373.         if (node->content->tag == NULL)
  2374.         {
  2375.             word = textFromOneNode( doc, node->content);
  2376.  
  2377.             for(i = 0; i < tmbstrlen (word); i++)
  2378.             {
  2379.                 if (word[i] == ' ')
  2380.                 {
  2381.                     numWords++;
  2382.                 }
  2383.             }
  2384.  
  2385.             if (numWords > 20)
  2386.             {
  2387.                 NeedsDescription = yes;
  2388.             }
  2389.         }
  2390.  
  2391.         /* Header following must be same level or same plus 1 for
  2392.         ** valid heading increase size.  E.g. H1 -> H1, H2.  H3 -> H3, H4
  2393.         */
  2394.         if ( nodeIsHeader(node) )
  2395.         {
  2396.             uint level = nodeHeaderLevel( node );
  2397.             IsValidIncrease = yes;
  2398.  
  2399.             for ( temp = node->next; temp != NULL; temp = temp->next )
  2400.             {
  2401.                 uint nested = nodeHeaderLevel( temp );
  2402.                 if ( nested >= level )
  2403.                 {
  2404.                     IsValidIncrease = ( nested <= level + 1 );
  2405.                     break;
  2406.                 }
  2407.             }
  2408.         }
  2409.  
  2410.         if ( !IsValidIncrease )
  2411.             ReportAccessWarning( doc, node, HEADERS_IMPROPERLY_NESTED );
  2412.     
  2413.         if ( NeedsDescription )
  2414.             ReportAccessWarning( doc, node, HEADER_USED_FORMAT_TEXT );    
  2415.     }
  2416. }
  2417.  
  2418.  
  2419. /*************************************************************
  2420. * CheckParagraphHeader
  2421. *
  2422. * Checks to ensure that P elements are not headings.  Must be
  2423. * greater than 10 words in length, and they must not be in bold,
  2424. * or italics, or underlined, etc.
  2425. *************************************************************/
  2426.  
  2427. static void CheckParagraphHeader( TidyDocImpl* doc, Node* node )
  2428. {
  2429.     Bool IsNotHeader = no;
  2430.     Node* temp;
  2431.  
  2432.     if ((doc->access.PRIORITYCHK == 2)||
  2433.         (doc->access.PRIORITYCHK == 3))
  2434.     {
  2435.         /* Cannot contain text formatting elements */
  2436.         if (node->content != NULL)   
  2437.         {                     
  2438.             if (node->content->tag != NULL)
  2439.             {
  2440.                 temp = node->content;
  2441.  
  2442.                 while (temp != NULL)
  2443.                 {
  2444.                     if (temp->tag == NULL)
  2445.                     {
  2446.                         IsNotHeader = yes;
  2447.                         break;
  2448.                     }
  2449.                         
  2450.                     temp = temp->next;
  2451.                 }
  2452.             }
  2453.  
  2454.             if ( !IsNotHeader )
  2455.             {
  2456.                 if ( nodeIsSTRONG(node->content) )
  2457.                 {
  2458.                     ReportAccessWarning( doc, node, POTENTIAL_HEADER_BOLD);
  2459.                 }
  2460.  
  2461.                 if ( nodeIsU(node->content) )
  2462.                 {
  2463.                     ReportAccessWarning( doc, node, POTENTIAL_HEADER_UNDERLINE);
  2464.                 }
  2465.  
  2466.                 if ( nodeIsEM(node->content) )
  2467.                 {
  2468.                     ReportAccessWarning( doc, node, POTENTIAL_HEADER_ITALICS);
  2469.                 }
  2470.             }
  2471.         }
  2472.     }
  2473. }
  2474.  
  2475.  
  2476. /*********************************************************
  2477. * CheckSelect
  2478. *
  2479. * Checks to see if a LABEL follows the SELECT element.
  2480. *********************************************************/
  2481.  
  2482. static void CheckSelect( TidyDocImpl* doc, Node* node )
  2483. {
  2484.     Node* temp;
  2485.     tmbstr label;
  2486.     int flag = 0;
  2487.  
  2488.     Bool HasLabelBefore = no;
  2489.     Bool HasLabelAfter = no;
  2490.  
  2491.     if ( doc->access.PRIORITYCHK == 2 ||
  2492.          doc->access.PRIORITYCHK == 3 )
  2493.     {
  2494.         /* Check to see if there is a LABEL preceding SELECT */
  2495.         if ( node->prev != NULL && node->prev->prev != NULL )
  2496.         {
  2497.             if ( nodeIsLABEL(node->prev->prev) )
  2498.             {
  2499.                 temp = node->prev->prev;
  2500.                 
  2501.                 if ( nodeIsText(temp->content) )
  2502.                 {
  2503.                     label = textFromOneNode( doc, temp->content );
  2504.                     if ( !IsWhitespace(label) )
  2505.                     {
  2506.                         flag = 1;
  2507.                         HasLabelBefore = yes;
  2508.                     }
  2509.                 }
  2510.             }
  2511.  
  2512.             /* Check to see if there is a LABEL following SELECT */
  2513.             if (flag == 0)
  2514.             {
  2515.                 if ( nodeIsLABEL(node) )
  2516.                 {
  2517.                     temp = node->next->next;
  2518.                     
  2519.                     if ( nodeIsText(temp->content) )
  2520.                     {
  2521.                         label = textFromOneNode( doc, temp->content );
  2522.                         if ( !IsWhitespace(label) )
  2523.                         {
  2524.                             flag = 1;
  2525.                             HasLabelAfter = yes;
  2526.                         }
  2527.                     }
  2528.                 }
  2529.             }
  2530.  
  2531.             if ( !HasLabelAfter )
  2532.                 ReportAccessError( doc, node, LABEL_NEEDS_REPOSITIONING_AFTER_INPUT);
  2533.  
  2534.             if (HasLabelBefore == no)
  2535.                 ReportAccessError( doc, node, LABEL_NEEDS_REPOSITIONING_BEFORE_INPUT);
  2536.         }
  2537.     }
  2538. }
  2539.  
  2540.  
  2541. /************************************************************
  2542. * CheckTextArea
  2543. *
  2544. * TEXTAREA must contain a label description either before 
  2545. * or after the TEXTAREA element. Text must exist within 
  2546. * TEXTAREA.
  2547. ************************************************************/
  2548.  
  2549. static void CheckTextArea( TidyDocImpl* doc, Node* node )
  2550. {
  2551.     int flag = 0;
  2552.     
  2553.     Bool HasLabelAfter = no;
  2554.     Bool HasLabelBefore = no;
  2555.  
  2556.     tmbstr label;
  2557.     Node* temp;
  2558.  
  2559.     if ((doc->access.PRIORITYCHK == 2)||
  2560.         (doc->access.PRIORITYCHK == 3))
  2561.     {
  2562.         /* Check to see if there is a LABEL before or after TEXTAREA */
  2563.         if (node->prev != NULL && node->prev->prev != NULL)
  2564.         {
  2565.             if ( nodeIsLABEL(node->prev->prev) )
  2566.             {
  2567.                 temp = node->prev->prev;
  2568.                 
  2569.                 if ( nodeIsText(temp->content) )
  2570.                 {
  2571.                     label = textFromOneNode( doc, temp->content );
  2572.                     if ( !IsWhitespace(label) )
  2573.                     {
  2574.                         flag = 1;
  2575.                         HasLabelBefore = yes;
  2576.                     }
  2577.                 }
  2578.             }
  2579.  
  2580.             if (flag == 0)
  2581.             {
  2582.                 if ( nodeIsLABEL(node->next->next) )
  2583.                 {
  2584.                     temp = node->next->next;
  2585.                     
  2586.                     if ( nodeIsText(temp->content) )
  2587.                     {
  2588.                         label = textFromOneNode( doc, temp->content);
  2589.                         if ( !IsWhitespace(label) )
  2590.                         {
  2591.                             flag = 1;
  2592.                             HasLabelAfter = yes;
  2593.                         }
  2594.                     }
  2595.                 }
  2596.             }
  2597.         
  2598.             if ( !HasLabelAfter )
  2599.                 ReportAccessError( doc, node, LABEL_NEEDS_REPOSITIONING_AFTER_INPUT);
  2600.  
  2601.             if ( !HasLabelBefore )
  2602.                 ReportAccessError( doc, node, LABEL_NEEDS_REPOSITIONING_BEFORE_INPUT);
  2603.         }
  2604.     }
  2605. }
  2606.  
  2607.  
  2608. /****************************************************************
  2609. * CheckEmbed
  2610. *
  2611. * Checks to see if 'SRC' is a multimedia type.  Must have 
  2612. * syncronized captions if used.
  2613. ****************************************************************/
  2614.  
  2615. static void CheckEmbed( TidyDocImpl* doc, Node* node )
  2616. {
  2617.     if ( doc->access.PRIORITYCHK == 1 ||
  2618.          doc->access.PRIORITYCHK == 2 ||
  2619.          doc->access.PRIORITYCHK == 3 )
  2620.     {
  2621.         AttVal* av = attrGetSRC( node );
  2622.         if ( hasValue(av) && IsValidMediaExtension(av->value) )
  2623.         {
  2624.              ReportAccessError( doc, node, MULTIMEDIA_REQUIRES_TEXT );
  2625.         }
  2626.     }
  2627. }
  2628.  
  2629.  
  2630. /*********************************************************************
  2631. * CheckHTMLAccess
  2632. *
  2633. * Checks HTML element for valid 'LANG' attribute.  Must be a valid
  2634. * language.  ie. 'fr' or 'en'
  2635. ********************************************************************/
  2636.  
  2637. static void CheckHTMLAccess( TidyDocImpl* doc, Node* node )
  2638. {
  2639.     Bool ValidLang = no;
  2640.  
  2641.     if ( doc->access.PRIORITYCHK == 3 )
  2642.     {
  2643.         AttVal* av = attrGetLANG( node );
  2644.         if ( av )
  2645.         {
  2646.             ValidLang = yes;
  2647.             if ( !hasValue(av) )
  2648.                 ReportAccessError( doc, node, LANGUAGE_INVALID );
  2649.         }
  2650.         if ( !ValidLang )
  2651.             ReportAccessError( doc, node, LANGUAGE_NOT_IDENTIFIED );
  2652.     }
  2653. }
  2654.  
  2655.  
  2656. /********************************************************
  2657. * CheckBlink
  2658. *
  2659. * Document must not contain the BLINK element.  
  2660. * It is invalid HTML/XHTML.
  2661. *********************************************************/
  2662.  
  2663. static void CheckBlink( TidyDocImpl* doc, Node* node )
  2664. {
  2665.     
  2666.     if ( doc->access.PRIORITYCHK == 2 ||
  2667.          doc->access.PRIORITYCHK == 3 )
  2668.     {
  2669.         /* Checks to see if text is found within the BLINK element. */
  2670.         if ( nodeIsText(node->content) )
  2671.         {
  2672.             tmbstr word = textFromOneNode( doc, node->content );
  2673.             if ( !IsWhitespace(word) )
  2674.             {
  2675.                 ReportAccessError( doc, node, REMOVE_BLINK_MARQUEE );
  2676.             }
  2677.         }
  2678.     }
  2679. }
  2680.  
  2681.  
  2682. /********************************************************
  2683. * CheckMarquee
  2684. *
  2685. * Document must not contain the MARQUEE element.
  2686. * It is invalid HTML/XHTML.
  2687. ********************************************************/
  2688.  
  2689.  
  2690. static void CheckMarquee( TidyDocImpl* doc, Node* node )
  2691. {
  2692.     if ( doc->access.PRIORITYCHK == 2 ||
  2693.          doc->access.PRIORITYCHK == 3 )
  2694.     {
  2695.         /* Checks to see if there is text in between the MARQUEE element */
  2696.         if ( nodeIsText(node) )
  2697.         {
  2698.             tmbstr word = textFromOneNode( doc, node->content);
  2699.             if ( !IsWhitespace(word) )
  2700.             {
  2701.                 ReportAccessError( doc, node, REMOVE_BLINK_MARQUEE );
  2702.             }
  2703.         }
  2704.     }
  2705. }
  2706.  
  2707.  
  2708. /**********************************************************
  2709. * CheckLink
  2710. *
  2711. * 'REL' attribute within the LINK element must not contain
  2712. * 'stylesheet'.  HTML/XHTML document is unreadable when
  2713. * style sheets are applied.  -- CPR huh?
  2714. **********************************************************/
  2715.  
  2716. static void CheckLink( TidyDocImpl* doc, Node* node )
  2717. {
  2718.     Bool HasRel = no;
  2719.     Bool HasType = no;
  2720.  
  2721.     if ( doc->access.PRIORITYCHK == 1 ||
  2722.          doc->access.PRIORITYCHK == 2 ||
  2723.          doc->access.PRIORITYCHK == 3 )
  2724.     {
  2725.         AttVal* av;
  2726.         /* Check for valid 'REL' and 'TYPE' attribute */
  2727.         for (av = node->attributes; av != NULL; av = av->next)
  2728.         {
  2729.             if ( attrIsREL(av) && hasValue(av) )
  2730.             {
  2731.                 if (AttrContains(av, "stylesheet"))
  2732.                     HasRel = yes;
  2733.             }
  2734.  
  2735.             if ( attrIsTYPE(av) && hasValue(av) )
  2736.             {
  2737.                 HasType = yes;
  2738.             }
  2739.         }
  2740.  
  2741.         ReportAccessWarning( doc, node, STYLESHEETS_REQUIRE_TESTING_LINK );
  2742.     }
  2743. }
  2744.  
  2745.  
  2746. /*******************************************************
  2747. * CheckStyle
  2748. *
  2749. * Document must not contain STYLE element.  HTML/XHTML 
  2750. * document is unreadable when style sheets are applied.
  2751. *******************************************************/
  2752.  
  2753. static void CheckStyle( TidyDocImpl* doc, Node* node )
  2754. {
  2755.     if ( doc->access.PRIORITYCHK == 1 ||
  2756.          doc->access.PRIORITYCHK == 2 ||
  2757.          doc->access.PRIORITYCHK == 3 )
  2758.     {
  2759.         ReportAccessWarning( doc, node, STYLESHEETS_REQUIRE_TESTING_STYLE_ELEMENT );
  2760.     }
  2761. }
  2762.  
  2763.  
  2764. /*************************************************************
  2765. * DynamicContent
  2766. *
  2767. * Verify that equivalents of dynamic content are updated and 
  2768. * available as often as the dynamic content.
  2769. *************************************************************/
  2770.  
  2771.  
  2772. static void DynamicContent( TidyDocImpl* doc, Node* node )
  2773. {
  2774.     if ( doc->access.PRIORITYCHK == 1 ||
  2775.          doc->access.PRIORITYCHK == 2 ||
  2776.          doc->access.PRIORITYCHK == 3 )
  2777.     {
  2778.         uint msgcode = 0;
  2779.         if ( nodeIsAPPLET(node) )
  2780.             msgcode = TEXT_EQUIVALENTS_REQUIRE_UPDATING_APPLET;
  2781.         else if ( nodeIsSCRIPT(node) )
  2782.             msgcode = TEXT_EQUIVALENTS_REQUIRE_UPDATING_SCRIPT;
  2783.         else if ( nodeIsOBJECT(node) )
  2784.             msgcode = TEXT_EQUIVALENTS_REQUIRE_UPDATING_OBJECT;
  2785.  
  2786.         if ( msgcode )
  2787.             ReportAccessWarning( doc, node, msgcode );
  2788.     }
  2789. }
  2790.  
  2791.  
  2792. /*************************************************************
  2793. * ProgrammaticObjects
  2794. *
  2795. * Verify that the page is usable when programmatic objects 
  2796. * are disabled.
  2797. *************************************************************/
  2798.  
  2799. static void ProgrammaticObjects( TidyDocImpl* doc, Node* node )
  2800. {
  2801.     if ( doc->access.PRIORITYCHK == 1 ||
  2802.          doc->access.PRIORITYCHK == 2 ||
  2803.          doc->access.PRIORITYCHK == 3 )
  2804.     {
  2805.         int msgcode = 0;
  2806.         if ( nodeIsSCRIPT(node) )
  2807.             msgcode = PROGRAMMATIC_OBJECTS_REQUIRE_TESTING_SCRIPT;
  2808.         else if ( nodeIsOBJECT(node) )
  2809.             msgcode = PROGRAMMATIC_OBJECTS_REQUIRE_TESTING_OBJECT;
  2810.         else if ( nodeIsEMBED(node) )
  2811.             msgcode = PROGRAMMATIC_OBJECTS_REQUIRE_TESTING_EMBED;
  2812.         else if ( nodeIsAPPLET(node) )
  2813.             msgcode = PROGRAMMATIC_OBJECTS_REQUIRE_TESTING_APPLET;
  2814.  
  2815.         if ( msgcode )
  2816.             ReportAccessWarning( doc, node, msgcode );
  2817.     }
  2818. }
  2819.  
  2820.  
  2821. /*************************************************************
  2822. * AccessibleCompatible
  2823. *
  2824. * Verify that programmatic objects are directly accessible.
  2825. *************************************************************/
  2826.  
  2827. static void AccessibleCompatible( TidyDocImpl* doc, Node* node )
  2828. {
  2829.     if ( doc->access.PRIORITYCHK == 1 ||
  2830.          doc->access.PRIORITYCHK == 2 ||
  2831.          doc->access.PRIORITYCHK == 3 )
  2832.     {
  2833.         int msgcode = 0;
  2834.         if ( nodeIsSCRIPT(node) )
  2835.             msgcode = ENSURE_PROGRAMMATIC_OBJECTS_ACCESSIBLE_SCRIPT;
  2836.         else if ( nodeIsOBJECT(node) )
  2837.             msgcode = ENSURE_PROGRAMMATIC_OBJECTS_ACCESSIBLE_OBJECT;
  2838.         else if ( nodeIsEMBED(node) )
  2839.             msgcode = ENSURE_PROGRAMMATIC_OBJECTS_ACCESSIBLE_EMBED;
  2840.         else if ( nodeIsAPPLET(node) )
  2841.             msgcode = ENSURE_PROGRAMMATIC_OBJECTS_ACCESSIBLE_APPLET;
  2842.  
  2843.         if ( msgcode )
  2844.             ReportAccessWarning( doc, node, msgcode );
  2845.     }
  2846. }
  2847.  
  2848.  
  2849. /********************************************************
  2850. * WordCount
  2851. *
  2852. * Counts the number of words in the document.  Must have
  2853. * more than 3 words to verify changes in natural
  2854. * language of document.
  2855. *
  2856. * CPR - Not sure what intent is here, but this 
  2857. * routine has nothing to do with changes in language.
  2858. * It seems like a bad idea to emit this message for
  2859. * every document with _more_ than 3 words!
  2860. ********************************************************/
  2861.  
  2862. static int WordCount( TidyDocImpl* doc, Node* node )
  2863. {
  2864.     int wc = 0;
  2865.  
  2866.     if ( doc->access.PRIORITYCHK == 1 ||
  2867.          doc->access.PRIORITYCHK == 2 ||
  2868.          doc->access.PRIORITYCHK == 3 )
  2869.     {
  2870.         /* Count the number of words found within a text node */
  2871.         if ( nodeIsText( node ) )
  2872.         {
  2873.             tmbchar ch;
  2874.             tmbstr word = textFromOneNode( doc, node );
  2875.             if ( !IsWhitespace(word) )
  2876.             {
  2877.                 ++wc;
  2878.                 while ( (ch = *word++) && wc < 5 )
  2879.                 {
  2880.                     if ( ch == ' ')
  2881.                         ++wc;
  2882.                 }
  2883.             }
  2884.         }
  2885.  
  2886.         for ( node = node->content; wc < 5 && node; node = node->next )
  2887.         {
  2888.             wc += WordCount( doc, node );
  2889.         }
  2890.     }
  2891.     return wc;
  2892. }
  2893.  
  2894.  
  2895. /**************************************************
  2896. * CheckFlicker
  2897. *
  2898. * Verify that the page does not cause flicker.
  2899. **************************************************/
  2900.  
  2901. static void CheckFlicker( TidyDocImpl* doc, Node* node )
  2902. {
  2903.     if ((doc->access.PRIORITYCHK == 1)||
  2904.         (doc->access.PRIORITYCHK == 2)||
  2905.         (doc->access.PRIORITYCHK == 3))
  2906.     {
  2907.         int msgcode = 0;
  2908.         if ( nodeIsSCRIPT(node) )
  2909.             msgcode = REMOVE_FLICKER_SCRIPT;
  2910.         else if ( nodeIsOBJECT(node) )
  2911.             msgcode = REMOVE_FLICKER_OBJECT;
  2912.         else if ( nodeIsEMBED(node) )
  2913.             msgcode = REMOVE_FLICKER_EMBED;
  2914.         else if ( nodeIsAPPLET(node) )
  2915.             msgcode = REMOVE_FLICKER_APPLET;
  2916.  
  2917.         /* Checks for animated gif within the <img> tag. */
  2918.         else if ( nodeIsIMG(node) )
  2919.         {
  2920.             AttVal* av = attrGetSRC( node );
  2921.             if ( hasValue(av) )
  2922.             {
  2923.                 tmbchar ext[20];
  2924.                 GetFileExtension( av->value, ext, sizeof(ext) );
  2925.                 if ( tmbstrcasecmp(ext, ".gif") == 0 )
  2926.                     msgcode = REMOVE_FLICKER_ANIMATED_GIF;
  2927.             }
  2928.         }            
  2929.  
  2930.         if ( msgcode )
  2931.             ReportAccessWarning( doc, node, msgcode );
  2932.     }
  2933. }
  2934.  
  2935.  
  2936. /**********************************************************
  2937. * CheckDeprecated
  2938. *
  2939. * APPLET, BASEFONT, CENTER, FONT, ISINDEX, 
  2940. * S, STRIKE, and U should not be used.  Becomes deprecated
  2941. * HTML if any of the above are used.
  2942. **********************************************************/
  2943.  
  2944. static void CheckDeprecated( TidyDocImpl* doc, Node* node )
  2945. {
  2946.     if ( doc->access.PRIORITYCHK == 2 ||
  2947.          doc->access.PRIORITYCHK == 3 )
  2948.     {
  2949.         int msgcode = 0;
  2950.         if ( nodeIsAPPLET(node) )
  2951.             msgcode = REPLACE_DEPRECATED_HTML_APPLET;
  2952.         else if ( nodeIsBASEFONT(node) )
  2953.             msgcode = REPLACE_DEPRECATED_HTML_BASEFONT;
  2954.         else if ( nodeIsCENTER(node) )
  2955.             msgcode = REPLACE_DEPRECATED_HTML_CENTER;
  2956.         else if ( nodeIsDIR(node) )
  2957.             msgcode = REPLACE_DEPRECATED_HTML_DIR;
  2958.         else if ( nodeIsFONT(node) )
  2959.             msgcode = REPLACE_DEPRECATED_HTML_FONT;
  2960.         else if ( nodeIsISINDEX(node) )
  2961.             msgcode = REPLACE_DEPRECATED_HTML_ISINDEX;
  2962.         else if ( nodeIsMENU(node) )
  2963.             msgcode = REPLACE_DEPRECATED_HTML_MENU;
  2964.         else if ( nodeIsS(node) )
  2965.             msgcode = REPLACE_DEPRECATED_HTML_S;
  2966.         else if ( nodeIsSTRIKE(node) )
  2967.             msgcode = REPLACE_DEPRECATED_HTML_STRIKE;
  2968.         else if ( nodeIsU(node) )
  2969.             msgcode = REPLACE_DEPRECATED_HTML_U;
  2970.  
  2971.         if ( msgcode )
  2972.             ReportAccessError( doc, node, msgcode );
  2973.     }
  2974. }
  2975.  
  2976.  
  2977. /************************************************************
  2978. * CheckScriptKeyboardAccessible
  2979. *
  2980. * Elements must have a device independent event handler if 
  2981. * they have any of the following device dependent event 
  2982. * handlers. 
  2983. ************************************************************/
  2984.  
  2985. static void CheckScriptKeyboardAccessible( TidyDocImpl* doc, Node* node )
  2986. {
  2987.     int HasOnMouseDown = 0;
  2988.     int HasOnMouseUp = 0;
  2989.     int HasOnClick = 0;
  2990.     int HasOnMouseOut = 0;
  2991.     int HasOnMouseOver = 0;
  2992.     int HasOnMouseMove = 0;
  2993.  
  2994.     if ( doc->access.PRIORITYCHK == 2 ||
  2995.          doc->access.PRIORITYCHK == 3 )
  2996.     {
  2997.         AttVal* av;
  2998.         /* Checks all elements for their attributes */
  2999.         for (av = node->attributes; av != NULL; av = av->next)
  3000.         {
  3001.             /* Must also have 'ONKEYDOWN' attribute with 'ONMOUSEDOWN' */
  3002.             if ( attrIsOnMOUSEDOWN(av) )
  3003.                 HasOnMouseDown++;
  3004.  
  3005.             /* Must also have 'ONKEYUP' attribute with 'ONMOUSEUP' */
  3006.             if ( attrIsOnMOUSEUP(av) )
  3007.                 HasOnMouseUp++;
  3008.  
  3009.             /* Must also have 'ONKEYPRESS' attribute with 'ONCLICK' */
  3010.             if ( attrIsOnCLICK(av) )
  3011.                 HasOnClick++;
  3012.  
  3013.             /* Must also have 'ONBLUR' attribute with 'ONMOUSEOUT' */
  3014.             if ( attrIsOnMOUSEOUT(av) )
  3015.                 HasOnMouseOut++;
  3016.  
  3017.             if ( attrIsOnMOUSEOVER(av) )
  3018.                 HasOnMouseOver++;
  3019.  
  3020.             if ( attrIsOnMOUSEMOVE(av) )
  3021.                 HasOnMouseMove++;
  3022.  
  3023.             if ( attrIsOnKEYDOWN(av) )
  3024.                 HasOnMouseDown++;
  3025.  
  3026.             if ( attrIsOnKEYUP(av) )
  3027.                 HasOnMouseUp++;
  3028.  
  3029.             if ( attrIsOnKEYPRESS(av) )
  3030.                 HasOnClick++;
  3031.  
  3032.             if ( attrIsOnBLUR(av) )
  3033.                 HasOnMouseOut++;
  3034.         }
  3035.  
  3036.         if ( HasOnMouseDown == 1 )
  3037.         {
  3038.             ReportAccessError( doc, node, SCRIPT_NOT_KEYBOARD_ACCESSIBLE_ON_MOUSE_DOWN);
  3039.         }
  3040.  
  3041.         if ( HasOnMouseUp == 1 )
  3042.         {
  3043.             ReportAccessError( doc, node, SCRIPT_NOT_KEYBOARD_ACCESSIBLE_ON_MOUSE_UP);
  3044.         }
  3045.         
  3046.         if ( HasOnClick == 1 )
  3047.         {
  3048.             ReportAccessError( doc, node, SCRIPT_NOT_KEYBOARD_ACCESSIBLE_ON_CLICK);
  3049.         }
  3050.             
  3051.         if ( HasOnMouseOut == 1 )
  3052.         {
  3053.             ReportAccessError( doc, node, SCRIPT_NOT_KEYBOARD_ACCESSIBLE_ON_MOUSE_OUT);
  3054.         }
  3055.         
  3056.         if ( HasOnMouseOver == 1 )
  3057.         {
  3058.             ReportAccessError( doc, node, SCRIPT_NOT_KEYBOARD_ACCESSIBLE_ON_MOUSE_OVER);
  3059.         }
  3060.  
  3061.         if ( HasOnMouseMove == 1 )
  3062.         {
  3063.             ReportAccessError( doc, node, SCRIPT_NOT_KEYBOARD_ACCESSIBLE_ON_MOUSE_MOVE);
  3064.         }
  3065.     }
  3066. }
  3067.  
  3068.  
  3069. /**********************************************************
  3070. * CheckMetaData
  3071. *
  3072. * Must have at least one of these elements in the document.
  3073. * META, LINK, TITLE or ADDRESS.  <meta> must contain 
  3074. * a "content" attribute that doesn't contain a URL, and
  3075. * an "http-Equiv" attribute that doesn't contain 'refresh'.
  3076. **********************************************************/
  3077.  
  3078.  
  3079. static Bool CheckMetaData( TidyDocImpl* doc, Node* node )
  3080. {
  3081.     Bool HasHttpEquiv = no;
  3082.     Bool HasContent = no;
  3083.     Bool HasRel = no;
  3084.     Bool ContainsAttr = no;
  3085.     Bool HasMetaData = no;
  3086.  
  3087.     if ( doc->access.PRIORITYCHK == 2 ||
  3088.          doc->access.PRIORITYCHK == 3 )
  3089.     {
  3090.         if ( nodeIsMETA(node) )
  3091.         {
  3092.             AttVal* av;
  3093.             for (av = node->attributes; av != NULL; av = av->next)
  3094.             {
  3095.                 if ( attrIsHTTP_EQUIV(av) && hasValue(av) )
  3096.                 {
  3097.                     ContainsAttr = yes;
  3098.  
  3099.                     /* Must not have an auto-refresh */
  3100.                     if (AttrValueIs(av, "refresh"))
  3101.                     {
  3102.                         HasHttpEquiv = yes;
  3103.                         ReportAccessError( doc, node, REMOVE_AUTO_REFRESH );
  3104.                     }
  3105.                 }
  3106.  
  3107.                 if ( attrIsCONTENT(av) && hasValue(av) )
  3108.                 {
  3109.                     ContainsAttr = yes;
  3110.  
  3111.                     /* If the value is not an integer, then it must not be a URL */
  3112.                     if ( tmbstrncmp(av->value, "http:", 5) == 0)
  3113.                     {
  3114.                         HasContent = yes;
  3115.                         ReportAccessError( doc, node, REMOVE_AUTO_REDIRECT);
  3116.                     }
  3117.                 }
  3118.             }
  3119.         
  3120.             if ( HasContent || HasHttpEquiv )
  3121.             {
  3122.                 HasMetaData = yes;
  3123.                 ReportAccessError( doc, node, METADATA_MISSING_REDIRECT_AUTOREFRESH);
  3124.             }
  3125.             else
  3126.             {
  3127.                 if ( ContainsAttr && !HasContent && !HasHttpEquiv )
  3128.                     HasMetaData = yes;                    
  3129.             }
  3130.         }
  3131.  
  3132.         if ( !HasMetaData && 
  3133.              nodeIsADDRESS(node) &&
  3134.              nodeIsA(node->content) )
  3135.         {
  3136.             HasMetaData = yes;
  3137.         }
  3138.             
  3139.         if ( !HasMetaData &&
  3140.              nodeIsTITLE(node) &&
  3141.              nodeIsText(node->content) )
  3142.         {
  3143.             tmbstr word = textFromOneNode( doc, node->content );
  3144.             if ( !IsWhitespace(word) )
  3145.                 HasMetaData = yes;
  3146.         }
  3147.  
  3148.         if ( !HasMetaData &&
  3149.              nodeIsLINK(node) )
  3150.         {
  3151.             AttVal* av = attrGetREL(node);
  3152.             HasMetaData = yes;
  3153.  
  3154.             if (AttrContains(av, "stylesheet"))
  3155.             {
  3156.                 HasRel = yes;
  3157.                 ReportAccessError( doc, node, METADATA_MISSING_LINK );
  3158.             }
  3159.         }
  3160.             
  3161.         /* Check for MetaData */
  3162.         for ( node = node->content; !HasMetaData && node; node = node->next )
  3163.         {
  3164.             HasMetaData = CheckMetaData( doc, node);
  3165.         }
  3166.     }
  3167.     return HasMetaData;
  3168. }
  3169.  
  3170.  
  3171. /*******************************************************
  3172. * MetaDataPresent
  3173. *
  3174. * Determines if MetaData is present in document
  3175. *******************************************************/
  3176.  
  3177. static void MetaDataPresent( TidyDocImpl* doc, Node* node )
  3178. {
  3179.     if ( doc->access.PRIORITYCHK == 2 ||
  3180.          doc->access.PRIORITYCHK == 3 )
  3181.     {
  3182.         ReportAccessError( doc, node, METADATA_MISSING );
  3183.     }
  3184. }
  3185.  
  3186.  
  3187. /*****************************************************
  3188. * CheckDocType
  3189. *
  3190. * Checks that every HTML/XHTML document contains a 
  3191. * '!DOCTYPE' before the root node. ie.  <HTML>
  3192. *****************************************************/
  3193.  
  3194. static void CheckDocType( TidyDocImpl* doc, Node* node )
  3195. {
  3196.     tmbstr word;
  3197.  
  3198.     if ((doc->access.PRIORITYCHK == 2)||
  3199.         (doc->access.PRIORITYCHK == 3))
  3200.     {
  3201.         if (node->tag == NULL)
  3202.         {
  3203.             word = textFromOneNode( doc, node->content);
  3204.                 
  3205.             if ((strstr (word, "HTML PUBLIC") == NULL) &&
  3206.                 (strstr (word, "html PUBLIC") == NULL))
  3207.             {
  3208.                 ReportAccessError( doc, node, DOCTYPE_MISSING);
  3209.             }
  3210.         }
  3211.     }
  3212. }
  3213.  
  3214.  
  3215.  
  3216. /********************************************************
  3217. * CheckMapLinks
  3218. *
  3219. * Checks to see if an HREF for A element matches HREF
  3220. * for AREA element.  There must be an HREF attribute 
  3221. * of an A element for every HREF of an AREA element. 
  3222. ********************************************************/
  3223.  
  3224. static Bool urlMatch( ctmbstr url1, ctmbstr url2 )
  3225. {
  3226.   /* TODO: Make host part case-insensitive and
  3227.   ** remainder case-sensitive.
  3228.   */
  3229.   return ( tmbstrcmp( url1, url2 ) == 0 );
  3230. }
  3231.  
  3232. static Bool FindLinkA( TidyDocImpl* doc, Node* node, ctmbstr url )
  3233. {
  3234.   Bool found = no;
  3235.   for ( node = node->content; !found && node; node = node->next )
  3236.   {
  3237.     if ( nodeIsA(node) )
  3238.     {
  3239.       AttVal* href = attrGetHREF( node );
  3240.       found = ( hasValue(href) && urlMatch(url, href->value) );
  3241.     }
  3242.     else
  3243.         found = FindLinkA( doc, node, url );
  3244.   }
  3245.   return found;
  3246. }
  3247.  
  3248. static void CheckMapLinks( TidyDocImpl* doc, Node* node )
  3249. {
  3250.     Node* child = node->content;
  3251.  
  3252.     /* Stores the 'HREF' link of an AREA element within a MAP element */
  3253.     for ( child = node->content; child != NULL; child = child->next )
  3254.     {
  3255.         if ( nodeIsAREA(child) )
  3256.         {
  3257.             /* Checks for 'HREF' attribute */                
  3258.             AttVal* href = attrGetHREF( child );
  3259.             if ( hasValue(href) &&
  3260.                  !FindLinkA( doc, &doc->root, href->value ) )
  3261.             {
  3262.                 ReportAccessError( doc, node, IMG_MAP_CLIENT_MISSING_TEXT_LINKS );
  3263.             }
  3264.         }
  3265.     }
  3266. }
  3267.  
  3268.  
  3269. /****************************************************
  3270. * CheckForStyleAttribute
  3271. *
  3272. * Checks all elements within the document to check 
  3273. * for the use of 'STYLE' attribute.
  3274. ****************************************************/
  3275.  
  3276. static void CheckForStyleAttribute( TidyDocImpl* doc, Node* node )
  3277. {
  3278.     if ( doc->access.PRIORITYCHK == 1 ||
  3279.          doc->access.PRIORITYCHK == 2 ||
  3280.          doc->access.PRIORITYCHK == 3 )
  3281.     {
  3282.         /* Must not contain 'STYLE' attribute */
  3283.         AttVal* style = attrGetSTYLE( node );
  3284.         if ( hasValue(style) )
  3285.         {
  3286.             ReportAccessWarning( doc, node, STYLESHEETS_REQUIRE_TESTING_STYLE_ATTR );
  3287.         }
  3288.     }
  3289. }
  3290.  
  3291.  
  3292. /*****************************************************
  3293. * CheckForListElements
  3294. *
  3295. * Checks document for list elements (<ol>, <ul>, <li>)
  3296. *****************************************************/
  3297.  
  3298. static void CheckForListElements( TidyDocImpl* doc, Node* node )
  3299. {
  3300.     if ( nodeIsLI(node) )
  3301.     {
  3302.         doc->access.ListElements++;
  3303.     }
  3304.     else if ( nodeIsOL(node) || nodeIsUL(node) )
  3305.     {
  3306.         doc->access.OtherListElements++;
  3307.     }
  3308.  
  3309.     for ( node = node->content; node != NULL; node = node->next )
  3310.     {
  3311.         CheckForListElements( doc, node );
  3312.     }
  3313. }
  3314.  
  3315.  
  3316. /******************************************************
  3317. * CheckListUsage
  3318. *
  3319. * Ensures that lists are properly used.  <ol> and <ul>
  3320. * must contain <li> within itself, and <li> must not be
  3321. * by itself.
  3322. ******************************************************/
  3323.  
  3324. static void CheckListUsage( TidyDocImpl* doc, Node* node )
  3325. {
  3326.     int msgcode = 0;
  3327.     if ( nodeIsOL(node) )
  3328.         msgcode = LIST_USAGE_INVALID_OL;
  3329.     else if ( nodeIsUL(node) )
  3330.         msgcode = LIST_USAGE_INVALID_UL;
  3331.  
  3332.     if ( msgcode )
  3333.     {
  3334.         if ( !nodeIsLI(node->content) )
  3335.             ReportAccessWarning( doc, node, msgcode );
  3336.     }
  3337.     else if ( nodeIsLI(node) )
  3338.     {
  3339.         /* Check that LI parent 
  3340.         ** a) exists,
  3341.         ** b) is either OL or UL
  3342.         */
  3343.         if ( node->parent == NULL ||
  3344.              ( !nodeIsOL(node->parent) && !nodeIsUL(node->parent) ) )
  3345.         {
  3346.             ReportAccessWarning( doc, node, LIST_USAGE_INVALID_LI );
  3347.         }
  3348.     }
  3349. }
  3350.  
  3351. /************************************************************
  3352. * InitAccessibilityChecks
  3353. *
  3354. * Initializes the AccessibilityChecks variables as necessary
  3355. ************************************************************/
  3356.  
  3357. void InitAccessibilityChecks( TidyDocImpl* doc, int level123 )
  3358. {
  3359.     ClearMemory( &doc->access, sizeof(doc->access) );
  3360.     doc->access.PRIORITYCHK = level123;
  3361. }
  3362.  
  3363. /************************************************************
  3364. * CleanupAccessibilityChecks
  3365. *
  3366. * Cleans up the AccessibilityChecks variables as necessary
  3367. ************************************************************/
  3368.  
  3369.  
  3370. void FreeAccessibilityChecks( TidyDocImpl* doc )
  3371. {
  3372. #pragma unused(doc)
  3373.  
  3374.     /* free any memory allocated for the lists
  3375.  
  3376.     Linked List of Links not used.  Just search document as 
  3377.     AREA tags are encountered.  Same algorithm, but no
  3378.     data structures necessary.
  3379.  
  3380.     current = start;
  3381.     while (current)
  3382.     {
  3383.         void    *templink = (void *)current;
  3384.         
  3385.         current = current->next;
  3386.         MemFree(templink);
  3387.     }
  3388.     start = NULL;
  3389.     */
  3390. }
  3391.  
  3392. /************************************************************
  3393. * AccessibilityChecks
  3394. *
  3395. * Traverses through the individual nodes of the tree
  3396. * and checks attributes and elements for accessibility.
  3397. * after the tree structure has been formed.
  3398. ************************************************************/
  3399.  
  3400. static void AccessibilityCheckNode( TidyDocImpl* doc, Node* node )
  3401. {
  3402.     Node* content;
  3403.     
  3404.     /* Check BODY for color contrast */
  3405.     if ( nodeIsBODY(node) )
  3406.     {
  3407.         CheckColorContrast( doc, node );
  3408.     }
  3409.  
  3410.     /* Checks document for MetaData */
  3411.     else if ( nodeIsHEAD(node) )
  3412.     {
  3413.         if ( !CheckMetaData( doc, node ) )
  3414.           MetaDataPresent( doc, node );
  3415.     }
  3416.     
  3417.     /* Check the ANCHOR tag */
  3418.     else if ( nodeIsA(node) )
  3419.     {
  3420.         CheckAnchorAccess( doc, node );
  3421.     }
  3422.  
  3423.     /* Check the IMAGE tag */
  3424.     else if ( nodeIsIMG(node) )
  3425.     {
  3426.         CheckFlicker( doc, node );
  3427.         CheckColorAvailable( doc, node );
  3428.         CheckImage( doc, node );
  3429.     }
  3430.  
  3431.         /* Checks MAP for client-side text links */
  3432.     else if ( nodeIsMAP(node) )
  3433.     {
  3434.         CheckMapLinks( doc, node );
  3435.     }
  3436.  
  3437.     /* Check the AREA tag */
  3438.     else if ( nodeIsAREA(node) )
  3439.     {
  3440.         CheckArea( doc, node );
  3441.     }
  3442.  
  3443.     /* Check the APPLET tag */
  3444.     else if ( nodeIsAPPLET(node) )
  3445.     {
  3446.         CheckDeprecated( doc, node );
  3447.         ProgrammaticObjects( doc, node );
  3448.         DynamicContent( doc, node );
  3449.         AccessibleCompatible( doc, node );
  3450.         CheckFlicker( doc, node );
  3451.         CheckColorAvailable( doc, node );
  3452.         CheckApplet(doc, node );
  3453.     }
  3454.     
  3455.     /* Check the OBJECT tag */
  3456.     else if ( nodeIsOBJECT(node) )
  3457.     {
  3458.         ProgrammaticObjects( doc, node );
  3459.         DynamicContent( doc, node );
  3460.         AccessibleCompatible( doc, node );
  3461.         CheckFlicker( doc, node );
  3462.         CheckColorAvailable( doc, node );
  3463.         CheckObject( doc, node );
  3464.     }
  3465.     
  3466.     /* Check the FRAME tag */
  3467.     else if ( nodeIsFRAME(node) )
  3468.     {
  3469.         CheckFrame( doc, node );
  3470.     }
  3471.     
  3472.     /* Check the IFRAME tag */
  3473.     else if ( nodeIsIFRAME(node) )
  3474.     {
  3475.         CheckIFrame( doc, node );
  3476.     }
  3477.     
  3478.     /* Check the SCRIPT tag */
  3479.     else if ( nodeIsSCRIPT(node) )
  3480.     {
  3481.         DynamicContent( doc, node );
  3482.         ProgrammaticObjects( doc, node );
  3483.         AccessibleCompatible( doc, node );
  3484.         CheckFlicker( doc, node );
  3485.         CheckColorAvailable( doc, node );
  3486.         CheckScriptAcc( doc, node );
  3487.     }
  3488.  
  3489.     /* Check the TABLE tag */
  3490.     else if ( nodeIsTABLE(node) )
  3491.     {
  3492.         CheckColorContrast( doc, node );
  3493.         CheckTable( doc, node );
  3494.     }
  3495.  
  3496.     /* Check the PRE for ASCII art */
  3497.     else if ( nodeIsPRE(node) || nodeIsXMP(node) )
  3498.     {
  3499.         CheckASCII( doc, node );
  3500.     }
  3501.  
  3502.     /* Check the LABEL tag */
  3503.     else if ( nodeIsLABEL(node) )
  3504.     {
  3505.         CheckLabel( doc, node );
  3506.     }
  3507.  
  3508.     /* Check INPUT tag for validity */
  3509.     else if ( nodeIsINPUT(node) )
  3510.     {
  3511.         CheckColorAvailable( doc, node );
  3512.         CheckInputLabel( doc, node );
  3513.         CheckInputAttributes( doc, node );
  3514.     }
  3515.  
  3516.     /* Checks FRAMESET element for NOFRAME section */
  3517.     else if ( nodeIsFRAMESET(node) )
  3518.     {
  3519.         CheckFrameSet( doc, node );
  3520.     }
  3521.     
  3522.     /* Checks for header elements for valid header increase */
  3523.     else if ( nodeIsHeader(node) )
  3524.     {
  3525.         CheckHeaderNesting( doc, node );
  3526.     }
  3527.  
  3528.     /* Checks P element to ensure that it is not a header */
  3529.     else if ( nodeIsP(node) )
  3530.     {
  3531.         CheckParagraphHeader( doc, node );
  3532.     }
  3533.  
  3534.     /* Checks SELECT element for LABEL */
  3535.     else if ( nodeIsSELECT(node) )
  3536.     {
  3537.         CheckSelect( doc, node );
  3538.     }
  3539.  
  3540.     /* Checks TEXTAREA element for LABEL */
  3541.     else if ( nodeIsTEXTAREA(node) )
  3542.     {
  3543.         CheckTextArea( doc, node );
  3544.     }
  3545.  
  3546.     /* Checks HTML elemnt for valid 'LANG' */
  3547.     else if ( nodeIsHTML(node) )
  3548.     {
  3549.         CheckHTMLAccess( doc, node );
  3550.     }
  3551.  
  3552.     /* Checks BLINK for any blinking text */
  3553.     else if ( nodeIsBLINK(node) )
  3554.     {
  3555.         CheckBlink( doc, node );
  3556.     }
  3557.  
  3558.     /* Checks MARQUEE for any MARQUEE text */
  3559.     else if ( nodeIsMARQUEE(node) )
  3560.     {
  3561.         CheckMarquee( doc, node );
  3562.     }
  3563.  
  3564.     /* Checks LINK for 'REL' attribute */
  3565.     else if ( nodeIsLINK(node) )
  3566.     {
  3567.         CheckLink( doc, node );
  3568.     }
  3569.  
  3570.     /* Checks to see if STYLE is used */
  3571.     else if ( nodeIsSTYLE(node) )
  3572.     {
  3573.         CheckColorContrast( doc, node );
  3574.         CheckStyle( doc, node );
  3575.     }
  3576.  
  3577.     /* Checks to see if EMBED is used */
  3578.     else if ( nodeIsEMBED(node) )
  3579.     {
  3580.         CheckEmbed( doc, node );
  3581.         ProgrammaticObjects( doc, node );
  3582.         AccessibleCompatible( doc, node );
  3583.         CheckFlicker( doc, node );
  3584.     }
  3585.  
  3586.     /* Deprecated HTML if the following tags are found in the document */
  3587.     else if ( nodeIsBASEFONT(node) ||
  3588.               nodeIsCENTER(node)   ||
  3589.               nodeIsISINDEX(node)  ||
  3590.               nodeIsU(node)        ||
  3591.               nodeIsFONT(node)     ||
  3592.               nodeIsDIR(node)      ||
  3593.               nodeIsS(node)        ||
  3594.               nodeIsSTRIKE(node)   ||
  3595.               nodeIsMENU(node) )
  3596.     {
  3597.         CheckDeprecated( doc, node );
  3598.     }
  3599.  
  3600.     /* Checks for 'ABBR' attribute if needed */
  3601.     else if ( nodeIsTH(node) )
  3602.     {
  3603.         CheckTH( doc, node );
  3604.     }
  3605.  
  3606.     /* Ensures that lists are properly used */
  3607.     else if ( nodeIsLI(node) || nodeIsOL(node) || nodeIsUL(node) )
  3608.     {
  3609.         CheckListUsage( doc, node );
  3610.     }
  3611.  
  3612.     /* Recursively check all child nodes.
  3613.     */
  3614.     for ( content = node->content; content != NULL; content = content->next )
  3615.     {
  3616.         AccessibilityCheckNode( doc, content );
  3617.     }
  3618. }
  3619.  
  3620.  
  3621. void AccessibilityChecks( TidyDocImpl* doc )
  3622. {
  3623.     /* Initialize */
  3624.     InitAccessibilityChecks( doc, cfg(doc, TidyAccessibilityCheckLevel) );
  3625.  
  3626.     /* Hello there, ladies and gentlemen... */
  3627.     AccessibilityHelloMessage( doc );
  3628.  
  3629.     /* Checks all elements for script accessibility */
  3630.     CheckScriptKeyboardAccessible( doc, &doc->root );
  3631.  
  3632.     /* Checks entire document for the use of 'STYLE' attribute */
  3633.     CheckForStyleAttribute( doc, &doc->root );
  3634.  
  3635.     /* Checks for '!DOCTYPE' */
  3636.     CheckDocType( doc, &doc->root );
  3637.  
  3638.     
  3639.     /* Checks to see if stylesheets are used to control the layout */
  3640.     if ( ! CheckMissingStyleSheets( doc, &doc->root ) )
  3641.     {
  3642.         ReportAccessWarning( doc, &doc->root, STYLE_SHEET_CONTROL_PRESENTATION );
  3643.     }
  3644.  
  3645.     /* Check to see if any list elements are found within the document */
  3646.     CheckForListElements( doc, &doc->root );
  3647.  
  3648.     /* Checks for natural language change */
  3649.     /* Must contain more than 3 words of text in the document
  3650.     **
  3651.     ** CPR - Not sure what intent is here, but this 
  3652.     ** routine has nothing to do with changes in language.
  3653.     ** It seems like a bad idea to emit this message for
  3654.     ** every document with _more_ than 3 words!
  3655.  
  3656.     if ( WordCount(doc, &doc->root) > 3 )
  3657.     {
  3658.         ReportAccessWarning( doc, node, INDICATE_CHANGES_IN_LANGUAGE);
  3659.     }
  3660.     */
  3661.  
  3662.  
  3663.     /* Recursively apply all remaining checks to 
  3664.     ** each node in document.
  3665.     */
  3666.     AccessibilityCheckNode( doc, &doc->root );
  3667.  
  3668.     /* Cleanup */
  3669.     FreeAccessibilityChecks( doc );
  3670. }
  3671.  
  3672. #endif
  3673.